home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / unix / ctags.1 < prev    next >
Text File  |  1989-03-15  |  52KB  |  1,694 lines
  1. Path: xanth!nic.MR.NET!hal!cwjcc!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i061:  tags - make a tags file for an editor
  5. Message-ID: <12245@swan.ulowell.edu>
  6. Date: 15 Mar 89 19:50:40 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 1683
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: grwalter@watcgl.waterloo.edu (Fred Walter)
  12. Posting-number: Volume 89, Issue 61
  13. Archive-name: unix/ctags.1
  14.  
  15. #    This is a shell archive.
  16. #    Remove everything above and including the cut line.
  17. #    Then run the rest of the file through sh.
  18. #----cut here-----cut here-----cut here-----cut here----#
  19. #!/bin/sh
  20. # shar:    Shell Archiver
  21. #    Run the following text with /bin/sh to create:
  22. #    README
  23. #    ORIGINAL_POSTER
  24. #    Makefile
  25. #    ctags.1
  26. #    ctags.c
  27. #    ctags.uu
  28. #    tags
  29. # This archive created: Wed Mar 15 14:47:08 1989
  30. cat << \SHAR_EOF > README
  31. /*
  32.  * The original of this version came over usenet (mod.sources Nov85).
  33.  * I also applied the bug fix mentioned in comp.bugs.4bsd Mar88.
  34.  *
  35.  * This was compiled with Lattice C 5.0
  36.  *
  37.  * G. R. Walter (Fred) February 29, 1989
  38.  */
  39. SHAR_EOF
  40. cat << \SHAR_EOF > ORIGINAL_POSTER
  41. Relay-Version: version B 2.10.2 9/18/84; site watmath.UUCP
  42. Posting-Version: version B 2.10.2 9/3/84; site panda.UUCP
  43. Path: watmath!clyde!burl!ulysses!allegra!mit-eddie!genrad!panda!sources-request
  44. From: sources-request@panda.UUCP
  45. Newsgroups: mod.sources
  46. Subject: ctags source
  47. Message-ID: <1145@panda.UUCP>
  48. Date: 30 Nov 85 18:21:54 GMT
  49. Date-Received: 1 Dec 85 04:02:09 GMT
  50. Sender: jpn@panda.UUCP
  51. Lines: 1184
  52. Approved: jpn@panda.UUCP
  53.  
  54. Mod.sources:  Volume 3, Issue 53
  55. Submitted by: ucbvax!ucsf-cgl.ARPA!arnold (Ken Arnold)
  56.  
  57.  
  58. #!/bin/sh
  59. #
  60. # I have received enough requests for the current source to ctags to
  61. # post it.  Here is the latest version (what will go out with 4.3,
  62. # modulo any bugs fixed during the beta period).  It is the 4.2 ctags
  63. # with recognition of yacc and lex tags added.  Files ending in .y are
  64. # presumed to be yacc files, .l files are either lisp or lex files,
  65. # depending upon the first non-blank character (yeah, it's a hack, but
  66. # it works).  Man page is included.  Note that I wrote the original
  67. # ctags (recognized only C), and added the YACC and lex after others
  68. # wrote the recognizers for FORTRAN, PASCAL, and lisp, so this code is
  69. # rather a mix of styles, for which I take no responsibility.  So, here
  70. # come those famous words:
  71. SHAR_EOF
  72. cat << \SHAR_EOF > Makefile
  73. #
  74. # Makefile for Lattice C 5.0 on Amiga
  75. #
  76.  
  77. .c.o:
  78.     lc $(CFLAGS) $<
  79.  
  80. CFLAGS = -cw -O
  81. LINKFLAGS = NODEBUG
  82. LIBS = lib:lc.lib
  83.  
  84. all: ctags
  85.     say "done all"
  86.  
  87. ctags: ctags.o
  88.     BLINK TO ctags FROM lib:cres.o ctags.o LIBRARY $(LIBS) $(LINKFLAGS)
  89.  
  90. clean:
  91.     delete ctags.o ctags
  92. SHAR_EOF
  93. cat << \SHAR_EOF > ctags.1
  94. .TH CTAGS 1 "25 August 1982"
  95. .UC 4
  96. .SH NAME
  97. ctags \- create a tags file
  98. .SH SYNOPSIS
  99. .B ctags
  100. [ 
  101. .B \-BFatuwvx
  102. ]
  103. name ...
  104. .SH DESCRIPTION
  105. .I Ctags
  106. makes a tags file for
  107. .IR ex (1)
  108. from the specified C, Pascal, Fortran, YACC, lex, and lisp sources.
  109. A tags file gives the locations of specified objects (in this case
  110. functions and typedefs) in a group of files.  Each line of the tags
  111. file contains the object name, the file in which it is defined, and
  112. an address specification for the object definition. Functions are
  113. searched with a pattern, typedefs with a line number. Specifiers are
  114. given in separate fields on the line, separated by blanks or tabs.
  115. Using the
  116. .I tags
  117. file,
  118. .I ex
  119. can quickly find these objects definitions.
  120. .PP
  121. If the
  122. .B \-x
  123. flag is given, 
  124. .I ctags
  125. produces a list of object names, the line number and file
  126. name on which each is defined, as well as the text of that line
  127. and prints this on the standard output.  This is a simple index
  128. which can be printed out as an off-line readable function index.
  129. .PP
  130. If the
  131. .B \-v
  132. flag is given,
  133. an index of the form expected by
  134. .IR vgrind (1)
  135. is produced on the standard output.
  136. This listing contains the function name,
  137. file name, and page number
  138. (assuming 64 line pages).
  139. Since the output will be sorted into lexicographic order,
  140. it may be desired to run the output through
  141. .BR "sort \-f" .
  142. Sample use:
  143. .nf
  144.     ctags \-v files | sort \-f > index
  145.     vgrind \-x index
  146. .fi
  147. .PP
  148. Files whose names end in 
  149. .B \.c
  150. or
  151. .B \.h
  152. are assumed to be C source files and are searched for C routine and
  153. macro definitions.
  154. Files whose names end in
  155. .B \.y
  156. are assumed to be YACC source files.
  157. Files whose names end in
  158. .B \.l
  159. are assumed to be either lisp files
  160. if their first non-blank character is `;', `(', or `[',
  161. or lex files otherwise.
  162. Other files are first examined to see if they contain any Pascal or
  163. Fortran routine definitions; if not, they are processed again
  164. looking for C definitions.
  165. .PP
  166. Other options are:
  167. .TP 5
  168. .B \-F
  169. use forward searching patterns (/.../) (default).
  170. .TP 5
  171. .B \-B
  172. use backward searching patterns (?...?).
  173. .TP 5
  174. .B \-a
  175. append to tags file.
  176. .TP 5
  177. .B \-t
  178. create tags for typedefs.
  179. .TP 5
  180. .B \-w
  181. suppressing warning diagnostics.
  182. .TP 5
  183. .B \-u
  184. causing the specified files to be
  185. .I updated
  186. in tags, that is, all references to them are deleted,
  187. and the new values are appended to the file.
  188. (Beware: this option is implemented in a way which is rather slow;
  189. it is usually faster to simply rebuild the
  190. .I tags
  191. file.)
  192. .PP
  193. The tag
  194. .I main
  195. is treated specially in C programs.
  196. The tag formed is created by prepending
  197. .I M
  198. to the name of the file, with a trailing .c removed, if
  199. any, and leading pathname components also removed.
  200. This makes use of
  201. .I ctags
  202. practical in directories with more than one program.
  203. .SH FILES
  204. .DT
  205. tags        output tags file
  206. .SH SEE ALSO
  207. ex(1), vi(1)
  208. .SH AUTHOR
  209. Ken Arnold; FORTRAN added by Jim Kleckner; Bill Joy
  210. added Pascal and
  211. .B \-x,
  212. replacing
  213. .I cxref;
  214. C typedefs added by Ed Pelegri-Llopart.
  215. .SH BUGS
  216. Recognition of \fBfunctions\fR, \fBsubroutines\fR and \fBprocedures\fR
  217. for FORTRAN and Pascal is done is a very simpleminded way.
  218. No attempt is made to deal with block structure; if you have two
  219. Pascal procedures in different blocks with the same name you lose.
  220. .PP
  221. The method of deciding whether to look for C or Pascal and FORTRAN
  222. functions is a hack.
  223. .PP
  224. Does not know about #ifdefs.
  225. .PP
  226. Should know about Pascal types.
  227. Relies on the input being well formed to detect typedefs.
  228. Use of -tx shows only the last line of typedefs.
  229. SHAR_EOF
  230. cat << \SHAR_EOF > ctags.c
  231. /* $Header */
  232.  
  233. static char *sccsid = "@(#)ctags.c    4.7 (Berkeley) 8/18/83";
  234.  
  235. #include <stdio.h>
  236. #include <ctype.h>
  237.  
  238. /*
  239.  * ctags: create a tags file
  240.  */
  241.  
  242. #define    reg    register
  243. #define    bool    char
  244.  
  245. #define    TRUE    (1)
  246. #define    FALSE    (0)
  247.  
  248. #define    iswhite(arg)    (_wht[arg])    /* T if char is white        */
  249. #define    begtoken(arg)    (_btk[arg])    /* T if char can start token    */
  250. #define    intoken(arg)    (_itk[arg])    /* T if char can be in token    */
  251. #define    endtoken(arg)    (_etk[arg])    /* T if char ends tokens    */
  252. #define    isgood(arg)    (_gd[arg])    /* T if char can be after ')'    */
  253.  
  254. /*
  255.  * The following ifndefs were necessary to get this to compile on an Amiga.
  256.  * The original of this version came over usenet (mod.sources Nov85).
  257.  * I also applied the bug fix mentioned in comp.bugs.4bsd Mar88.
  258.  *
  259.  * Compile with Amiga Lattice C using : lc -cw -L ctags
  260.  *
  261.  * G. R. Walter (Fred) December 30, 1988
  262.  */
  263. #ifndef AMIGA
  264. # define    max(I1,I2)    (I1 > I2 ? I1 : I2)
  265. #endif
  266. #ifdef AMIGA
  267. # define entry EnTrY
  268. # define index(S, C) strchr(S, C)
  269. # define cfree(C) free(C)
  270. #endif
  271.  
  272. struct    nd_st {                 /* sorting structure        */
  273.     char    *entry;            /* function or type name    */
  274.     char    *file;            /* file name            */
  275.     bool    f;            /* use pattern or line no    */
  276.     int    lno;            /* for -x option        */
  277.     char    *pat;            /* search pattern        */
  278.     bool    been_warned;        /* set if noticed dup        */
  279.     struct    nd_st    *left,*right;    /* left and right sons        */
  280. };
  281.  
  282. long    ftell();
  283. typedef    struct    nd_st    NODE;
  284.  
  285. bool    number,                /* T if on line starting with #    */
  286.     term    = FALSE,        /* T if print on terminal    */
  287.     makefile= TRUE,            /* T if to creat "tags" file    */
  288.     gotone,                /* found a func already on line    */
  289.                     /* boolean "func" (see init)    */
  290.     _wht[0177],_etk[0177],_itk[0177],_btk[0177],_gd[0177];
  291.  
  292.     /* typedefs are recognized using a simple finite automata,
  293.      * tydef is its state variable.
  294.      */
  295. typedef enum {none, begin, middle, end } TYST;
  296.  
  297. TYST tydef = none;
  298.  
  299. char    searchar = '/';            /* use /.../ searches         */
  300.  
  301. int    lineno;                /* line number of current line */
  302. char    line[4*BUFSIZ],        /* current input line            */
  303.     *curfile,        /* current input file name        */
  304.     *outfile= "tags",    /* output file                */
  305.     *white    = " \f\t\n",    /* white chars                */
  306.     *endtk    = " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?",
  307.                 /* token ending chars            */
  308.     *begtk    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
  309.                 /* token starting chars            */
  310.     *intk    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0123456789",
  311.                 /* valid in-token chars            */
  312.     *notgd    = ",;";        /* non-valid after-function chars    */
  313.  
  314. int    file_num;        /* current file number            */
  315. int    aflag;            /* -a: append to tags */
  316. int    tflag;            /* -t: create tags for typedefs */
  317. int    uflag;            /* -u: update tags */
  318. int    wflag;            /* -w: suppress warnings */
  319. int    vflag;            /* -v: create vgrind style index output */
  320. int    xflag;            /* -x: create cxref style output */
  321.  
  322. char    lbuf[BUFSIZ];
  323.  
  324. FILE    *inf,            /* ioptr for current input file        */
  325.     *outf;            /* ioptr for tags file            */
  326.  
  327. long    lineftell;        /* ftell after getc( inf ) == '\n'     */
  328.  
  329. NODE    *head;            /* the head of the sorted binary tree    */
  330.  
  331. char    *savestr();
  332. #ifdef AMIGA
  333. char    *rindex(), *strchr();
  334. #else
  335. char    *rindex(), *index();
  336. #endif
  337. char    *toss_comment();
  338.  
  339. main(ac,av)
  340. int    ac;
  341. char    *av[];
  342. {
  343.     char cmd[100];
  344.     int i;
  345.  
  346.     while (ac > 1 && av[1][0] == '-') {
  347.         for (i=1; av[1][i]; i++) {
  348.             switch(av[1][i]) {
  349.               case 'B':
  350.                 searchar='?';
  351.                 break;
  352.               case 'F':
  353.                 searchar='/';
  354.                 break;
  355.               case 'a':
  356.                 aflag++;
  357.                 break;
  358.               case 't':
  359.                 tflag++;
  360.                 break;
  361.               case 'u':
  362.                 uflag++;
  363.                 break;
  364.               case 'w':
  365.                 wflag++;
  366.                 break;
  367.               case 'v':
  368.                 vflag++;
  369.                 xflag++;
  370.                 break;
  371.               case 'x':
  372.                 xflag++;
  373.                 break;
  374.               default:
  375.                 goto usage;
  376.         }
  377.         }
  378.         ac--; av++;
  379.     }
  380.  
  381.     if (ac <= 1) {
  382. usage:
  383.         printf("Usage: ctags [-BFatuwvx] file ...\n");
  384.         exit(1);
  385.     }
  386.  
  387.     init();            /* set up boolean "functions"        */
  388.     /*
  389.      * loop through files finding functions
  390.      */
  391.     for (file_num = 1; file_num < ac; file_num++)
  392.         find_entries(av[file_num]);
  393.  
  394.     if (xflag) {
  395.         put_entries(head);
  396.         exit(0);
  397.     }
  398.     if (uflag) {
  399.         for (i=1; i<ac; i++) {
  400.             sprintf(cmd,
  401.                 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
  402.                 outfile, av[i], outfile);
  403.             system(cmd);
  404.         }
  405.         aflag++;
  406.     }
  407.     outf = fopen(outfile, aflag ? "a" : "w");
  408.     if (outf == NULL) {
  409.         perror(outfile);
  410.         exit(1);
  411.     }
  412.     put_entries(head);
  413.     fclose(outf);
  414.     if (uflag) {
  415.         sprintf(cmd, "sort %s -o %s", outfile, outfile);
  416.         system(cmd);
  417.     }
  418.     exit(0);
  419. }
  420.  
  421. /*
  422.  * This routine sets up the boolean psuedo-functions which work
  423.  * by seting boolean flags dependent upon the corresponding character
  424.  * Every char which is NOT in that string is not a white char.  Therefore,
  425.  * all of the array "_wht" is set to FALSE, and then the elements
  426.  * subscripted by the chars in "white" are set to TRUE.  Thus "_wht"
  427.  * of a char is TRUE if it is the string "white", else FALSE.
  428.  */
  429. init()
  430. {
  431.  
  432.     reg    char    *sp;
  433.     reg    int    i;
  434.  
  435.     for (i = 0; i < 0177; i++) {
  436.         _wht[i] = _etk[i] = _itk[i] = _btk[i] = FALSE;
  437.         _gd[i] = TRUE;
  438.     }
  439.     for (sp = white; *sp; sp++)
  440.         _wht[*sp] = TRUE;
  441.     for (sp = endtk; *sp; sp++)
  442.         _etk[*sp] = TRUE;
  443.     for (sp = intk; *sp; sp++)
  444.         _itk[*sp] = TRUE;
  445.     for (sp = begtk; *sp; sp++)
  446.         _btk[*sp] = TRUE;
  447.     for (sp = notgd; *sp; sp++)
  448.         _gd[*sp] = FALSE;
  449. }
  450.  
  451. /*
  452.  * This routine opens the specified file and calls the function
  453.  * which finds the function and type definitions.
  454.  */
  455. find_entries(file)
  456. char    *file;
  457. {
  458.     char *cp;
  459.  
  460.     if ((inf = fopen(file,"r")) == NULL) {
  461.         perror(file);
  462.         return;
  463.     }
  464.     curfile = savestr(file);
  465.     lineno = 0;
  466.     cp = rindex(file, '.');
  467.     /* .l implies lisp or lex source code */
  468.     if (cp && cp[1] == 'l' && cp[2] == '\0') {
  469.         if (index(";([", first_char()) != NULL) {    /* lisp */
  470.             L_funcs(inf);
  471.             fclose(inf);
  472.             return;
  473.         }
  474.         else {                        /* lex */
  475.             /*
  476.              * throw away all the code before the second "%%"
  477.              */
  478.             toss_yysec();
  479.             getline();
  480.             pfnote("yylex", lineno, TRUE);
  481.             toss_yysec();
  482.             C_entries();
  483.             fclose(inf);
  484.             return;
  485.         }
  486.     }
  487.     /* .y implies a yacc file */
  488.     if (cp && cp[1] == 'y' && cp[2] == '\0') {
  489.         toss_yysec();
  490.         Y_entries();
  491.         C_entries();
  492.         fclose(inf);
  493.         return;
  494.     }
  495.     /* if not a .c or .h file, try fortran */
  496.     if (cp && (cp[1] != 'c' && cp[1] != 'h') && cp[2] == '\0') {
  497.         if (PF_funcs(inf) != 0) {
  498.             fclose(inf);
  499.             return;
  500.         }
  501.         rewind(inf);    /* no fortran tags found, try C */
  502.     }
  503.     C_entries();
  504.     fclose(inf);
  505. }
  506.  
  507. pfnote(name, ln, f)
  508. char    *name;
  509. int    ln;
  510. bool    f;        /* f == TRUE when function */
  511. {
  512.     register char *fp;
  513.     register NODE *np;
  514.     char nbuf[BUFSIZ];
  515.  
  516.     if ((np = (NODE *) malloc(sizeof (NODE))) == NULL) {
  517.         fprintf(stderr, "ctags: too many entries to sort\n");
  518.         put_entries(head);
  519.         free_tree(head);
  520.         head = np = (NODE *) malloc(sizeof (NODE));
  521.     }
  522.     if (xflag == 0 && !strcmp(name, "main")) {
  523.         fp = rindex(curfile, '/');
  524.         if (fp == 0)
  525.             fp = curfile;
  526.         else
  527.             fp++;
  528.         sprintf(nbuf, "M%s", fp);
  529.         fp = rindex(nbuf, '.');
  530.         if (fp && fp[2] == 0)
  531.             *fp = 0;
  532.         name = nbuf;
  533.     }
  534.     np->entry = savestr(name);
  535.     np->file = curfile;
  536.     np->f = f;
  537.     np->lno = ln;
  538.     np->left = np->right = 0;
  539.     if (xflag == 0) {
  540.         lbuf[50] = 0;
  541.         strcat(lbuf, "$");
  542.         lbuf[50] = 0;
  543.     }
  544.     np->pat = savestr(lbuf);
  545.     if (head == NULL)
  546.         head = np;
  547.     else
  548.         add_node(np, head);
  549. }
  550.  
  551. /*
  552.  * This routine finds functions and typedefs in C syntax and adds them
  553.  * to the list.
  554.  */
  555. C_entries()
  556. {
  557.     register int c;
  558.     register char *token, *tp;
  559.     bool incomm, inquote, inchar, midtoken;
  560.     int level;
  561.     char *sp;
  562.     char tok[BUFSIZ];
  563.  
  564.     number = gotone = midtoken = inquote = inchar = incomm = FALSE;
  565.     level = 0;
  566.     sp = tp = token = line;
  567.     lineno++;
  568.     lineftell = ftell(inf);
  569.     for (;;) {
  570.         *sp = c = getc(inf);
  571.         if (feof(inf))
  572.             break;
  573.         if (c == '\n')
  574.             lineno++;
  575.         else if (c == '\\') {
  576.             c = *++sp = getc(inf);
  577.             if (c == '\n')
  578.                 c = ' ';
  579.         }
  580.         else if (incomm) {
  581.             if (c == '*') {
  582.                 while ((*++sp=c=getc(inf)) == '*')
  583.                     continue;
  584.                 if (c == '\n')
  585.                     lineno++;
  586.                 if (c == '/')
  587.                     incomm = FALSE;
  588.             }
  589.         }
  590.         else if (inquote) {
  591.             /*
  592.              * Too dumb to know about \" not being magic, but
  593.              * they usually occur in pairs anyway.
  594.              */
  595.             if (c == '"')
  596.                 inquote = FALSE;
  597.             continue;
  598.         }
  599.         else if (inchar) {
  600.             if (c == '\'')
  601.                 inchar = FALSE;
  602.             continue;
  603.         }
  604.         else switch (c) {
  605.           case '"':
  606.             inquote = TRUE;
  607.             continue;
  608.           case '\'':
  609.             inchar = TRUE;
  610.             continue;
  611.           case '/':
  612.             if ((*++sp=c=getc(inf)) == '*')
  613.                 incomm = TRUE;
  614.             else
  615.                 ungetc(*sp, inf);
  616.             continue;
  617.           case '#':
  618.             if (sp == line)
  619.                 number = TRUE;
  620.             continue;
  621.           case '{':
  622.             if (tydef == begin) {
  623.                 tydef=middle;
  624.             }
  625.             level++;
  626.             continue;
  627.           case '}':
  628.             if (sp == line)
  629.                 level = 0;    /* reset */
  630.             else
  631.                 level--;
  632.             if (!level && tydef==middle) {
  633.                 tydef=end;
  634.             }
  635.             continue;
  636.         }
  637.         if (!level && !inquote && !incomm && gotone == FALSE) {
  638.             if (midtoken) {
  639.                 if (endtoken(c)) {
  640.                     int f;
  641.                     int pfline = lineno;
  642.                     if (start_entry(&sp,token,tp,&f)) {
  643.                         strncpy(tok,token,tp-token+1);
  644.                         tok[tp-token+1] = 0;
  645.                         getline();
  646.                         pfnote(tok, pfline, f);
  647.                         gotone = f;    /* function */
  648.                     }
  649.                     midtoken = FALSE;
  650.                     token = sp;
  651.                 }
  652.                 else if (intoken(c))
  653.                     tp++;
  654.             }
  655.             else if (begtoken(c)) {
  656.                 token = tp = sp;
  657.                 midtoken = TRUE;
  658.             }
  659.         }
  660.         if (c == ';'  &&  tydef==end)    /* clean with typedefs */
  661.             tydef=none;
  662.         sp++;
  663.         if (c == '\n' || sp > &line[sizeof (line) - BUFSIZ]) {
  664.             tp = token = sp = line;
  665.             lineftell = ftell(inf);
  666.             number = gotone = midtoken = inquote = inchar = FALSE;
  667.         }
  668.     }
  669. }
  670.  
  671. /*
  672.  * This routine  checks to see if the current token is
  673.  * at the start of a function, or corresponds to a typedef
  674.  * It updates the input line * so that the '(' will be
  675.  * in it when it returns.
  676.  */
  677. start_entry(lp,token,tp,f)
  678. char    **lp,*token,*tp;
  679. int    *f;
  680. {
  681.     reg    char    c,*sp;
  682.     static    bool    found;
  683.     bool    firsttok;        /* T if have seen first token in ()'s */
  684.     int    bad;
  685.  
  686.     *f = 1;            /* a function */
  687.     sp = *lp;
  688.     c = *sp;
  689.     bad = FALSE;
  690.     if (!number) {        /* space is not allowed in macro defs    */
  691.         while (iswhite(c)) {
  692.             *++sp = c = getc(inf);
  693.             if (c == '\n') {
  694.                 lineno++;
  695.                 if (sp > &line[sizeof (line) - BUFSIZ])
  696.                     goto ret;
  697.             }
  698.         }
  699.     /* the following tries to make it so that a #define a b(c)    */
  700.     /* doesn't count as a define of b.                */
  701.     }
  702.     else {
  703.         if (!strncmp(token, "define", 6))
  704.             found = 0;
  705.         else
  706.             found++;
  707.         if (found >= 2) {
  708.             gotone = TRUE;
  709. badone:            bad = TRUE;
  710.             goto ret;
  711.         }
  712.     }
  713.     /* check for the typedef cases        */
  714.     if (tflag && !strncmp(token, "typedef", 7)) {
  715.         tydef=begin;
  716.         goto badone;
  717.     }
  718.     if (tydef==begin && (!strncmp(token, "struct", 6) ||
  719.         !strncmp(token, "union", 5) || !strncmp(token, "enum", 4))) {
  720.         goto badone;
  721.     }
  722.     if (tydef==begin) {
  723.         tydef=end;
  724.         goto badone;
  725.     }
  726.     if (tydef==end) {
  727.         *f = 0;
  728.         goto ret;
  729.     }
  730.     if (c != '(')
  731.         goto badone;
  732.     firsttok = FALSE;
  733.     while ((*++sp=c=getc(inf)) != ')') {
  734.         if (c == '\n') {
  735.             lineno++;
  736.             if (sp > &line[sizeof (line) - BUFSIZ])
  737.                 goto ret;
  738.         }
  739.         /*
  740.          * This line used to confuse ctags:
  741.          *    int    (*oldhup)();
  742.          * This fixes it. A nonwhite char before the first
  743.          * token, other than a / (in case of a comment in there)
  744.          * makes this not a declaration.
  745.          */
  746.         if (begtoken(c) || c=='/')
  747.             firsttok++;
  748.         else if (!iswhite(c) && !firsttok)
  749.             goto badone;
  750.     }
  751.     while (iswhite(*++sp=c=getc(inf)))
  752.         if (c == '\n') {
  753.             lineno++;
  754.             if (sp > &line[sizeof (line) - BUFSIZ])
  755.                 break;
  756.         }
  757. ret:
  758.     *lp = --sp;
  759.     if (c == '\n')
  760.         lineno--;
  761.     ungetc(c,inf);
  762.     return !bad && (!*f || isgood(c));
  763.                     /* hack for typedefs */
  764. }
  765.  
  766. /*
  767.  * Y_entries:
  768.  *    Find the yacc tags and put them in.
  769.  */
  770. Y_entries()
  771. {
  772.     register char    *sp, *orig_sp;
  773.     register int    brace;
  774.     register bool    in_rule, toklen;
  775.     char        tok[BUFSIZ];
  776.  
  777.     brace = 0;
  778.     getline();
  779.     pfnote("yyparse", lineno, TRUE);
  780.     while (fgets(line, sizeof line, inf) != NULL)
  781.         for (sp = line; *sp; sp++)
  782.             switch (*sp) {
  783.               case '\n':
  784.                 lineno++;
  785.                 /* FALLTHROUGH */
  786.               case ' ':
  787.               case '\t':
  788.               case '\f':
  789.               case '\r':
  790.                 break;
  791.               case '"':
  792.                 do {
  793.                     while (*++sp != '"')
  794.                         continue;
  795.                 } while (sp[-1] == '\\');
  796.                 break;
  797.               case '\'':
  798.                 do {
  799.                     while (*++sp != '\'')
  800.                         continue;
  801.                 } while (sp[-1] == '\\');
  802.                 break;
  803.               case '/':
  804.                 if (*++sp == '*')
  805.                     sp = toss_comment(sp);
  806.                 else
  807.                     --sp;
  808.                 break;
  809.               case '{':
  810.                 brace++;
  811.                 break;
  812.               case '}':
  813.                 brace--;
  814.                 break;
  815.               case '%':
  816.                 if (sp[1] == '%' && sp == line)
  817.                     return;
  818.                 break;
  819.               case '|':
  820.               case ';':
  821.                 in_rule = FALSE;
  822.                 break;
  823.               default:
  824.                 if (brace == 0  && !in_rule && (isalpha(*sp) ||
  825.                                 *sp == '.' ||
  826.                                 *sp == '_')) {
  827.                     orig_sp = sp;
  828.                     ++sp;
  829.                     while (isalnum(*sp) || *sp == '_' ||
  830.                            *sp == '.')
  831.                         sp++;
  832.                     toklen = sp - orig_sp;
  833.                     while (isspace(*sp))
  834.                         sp++;
  835.                     if (*sp == ':' || (*sp == '\0' &&
  836.                                first_char() == ':'))
  837.                     {
  838.                         strncpy(tok, orig_sp, toklen);
  839.                         tok[toklen] = '\0';
  840.                         strcpy(lbuf, line);
  841.                         lbuf[strlen(lbuf) - 1] = '\0';
  842.                         pfnote(tok, lineno, TRUE);
  843.                         in_rule = TRUE;
  844.                     }
  845.                     else
  846.                         sp--;
  847.                 }
  848.                 break;
  849.             }
  850. }
  851.  
  852. char *
  853. toss_comment(start)
  854. char    *start;
  855. {
  856.     register char    *sp;
  857.  
  858.     /*
  859.      * first, see if the end-of-comment is on the same line
  860.      */
  861.     do {
  862.         while ((sp = index(start, '*')) != NULL)
  863.             if (sp[1] == '/')
  864.                 return ++sp;
  865.             else
  866.                 start = ++sp;
  867.         start = line;
  868.         lineno++;
  869.     } while (fgets(line, sizeof line, inf) != NULL);
  870. }
  871.  
  872. getline()
  873. {
  874.     long saveftell = ftell( inf );
  875.     register char *cp;
  876.  
  877.     fseek( inf , lineftell , 0 );
  878.     fgets(lbuf, sizeof lbuf, inf);
  879.     cp = rindex(lbuf, '\n');
  880.     if (cp)
  881.         *cp = 0;
  882.     fseek(inf, saveftell, 0);
  883. }
  884.  
  885. free_tree(node)
  886. NODE    *node;
  887. {
  888.  
  889.     while (node) {
  890.         free_tree(node->right);
  891.         cfree(node);
  892.         node = node->left;
  893.     }
  894. }
  895.  
  896. add_node(node, cur_node)
  897.     NODE *node,*cur_node;
  898. {
  899.     register int dif;
  900.  
  901.     dif = strcmp(node->entry, cur_node->entry);
  902.     if (dif == 0) {
  903.         if (node->file == cur_node->file) {
  904.             if (!wflag) {
  905. fprintf(stderr,"Duplicate entry in file %s, line %d: %s\n",
  906.     node->file,lineno,node->entry);
  907. fprintf(stderr,"Second entry ignored\n");
  908.             }
  909.             return;
  910.         }
  911.         if (!cur_node->been_warned)
  912.             if (!wflag)
  913. fprintf(stderr,"Duplicate entry in files %s and %s: %s (Warning only)\n",
  914.     node->file, cur_node->file, node->entry);
  915.         cur_node->been_warned = TRUE;
  916.         return;
  917.     }
  918.  
  919.     if (dif < 0) {
  920.         if (cur_node->left != NULL)
  921.             add_node(node,cur_node->left);
  922.         else
  923.             cur_node->left = node;
  924.         return;
  925.     }
  926.     if (cur_node->right != NULL)
  927.         add_node(node,cur_node->right);
  928.     else
  929.         cur_node->right = node;
  930. }
  931.  
  932. put_entries(node)
  933. reg NODE    *node;
  934. {
  935.     reg char    *sp;
  936.  
  937.     if (node == NULL)
  938.         return;
  939.     put_entries(node->left);
  940.     if (xflag == 0)
  941.         if (node->f) {        /* a function */
  942.             fprintf(outf, "%s\t%s\t%c^",
  943.                 node->entry, node->file, searchar);
  944.             for (sp = node->pat; *sp; sp++)
  945.                 if (*sp == '\\')
  946.                     fprintf(outf, "\\\\");
  947.                 else if (*sp == searchar)
  948.                     fprintf(outf, "\\%c", searchar);
  949.                 else
  950.                     putc(*sp, outf);
  951.             fprintf(outf, "%c\n", searchar);
  952.         }
  953.         else {        /* a typedef; text pattern inadequate */
  954.             fprintf(outf, "%s\t%s\t%d\n",
  955.                 node->entry, node->file, node->lno);
  956.         }
  957.     else if (vflag)
  958.         fprintf(stdout, "%s %s %d\n",
  959.                 node->entry, node->file, (node->lno+63)/64);
  960.     else
  961.         fprintf(stdout, "%-16s%4d %-16s %s\n",
  962.             node->entry, node->lno, node->file, node->pat);
  963.     put_entries(node->right);
  964. }
  965. char    *dbp = lbuf;
  966. int    pfcnt;
  967.  
  968. PF_funcs(fi)
  969.     FILE *fi;
  970. {
  971.  
  972.     pfcnt = 0;
  973.     while (fgets(lbuf, sizeof(lbuf), fi)) {
  974.         lineno++;
  975.         dbp = lbuf;
  976.         if ( *dbp == '%' ) dbp++ ;    /* Ratfor escape to fortran */
  977.         while (isspace(*dbp))
  978.             dbp++;
  979.         if (*dbp == 0)
  980.             continue;
  981.         switch (*dbp |' ') {
  982.  
  983.           case 'i':
  984.             if (tail("integer"))
  985.                 takeprec();
  986.             break;
  987.           case 'r':
  988.             if (tail("real"))
  989.                 takeprec();
  990.             break;
  991.           case 'l':
  992.             if (tail("logical"))
  993.                 takeprec();
  994.             break;
  995.           case 'c':
  996.             if (tail("complex") || tail("character"))
  997.                 takeprec();
  998.             break;
  999.           case 'd':
  1000.             if (tail("double")) {
  1001.                 while (isspace(*dbp))
  1002.                     dbp++;
  1003.                 if (*dbp == 0)
  1004.                     continue;
  1005.                 if (tail("precision"))
  1006.                     break;
  1007.                 continue;
  1008.             }
  1009.             break;
  1010.         }
  1011.         while (isspace(*dbp))
  1012.             dbp++;
  1013.         if (*dbp == 0)
  1014.             continue;
  1015.         switch (*dbp|' ') {
  1016.  
  1017.           case 'f':
  1018.             if (tail("function"))
  1019.                 getit();
  1020.             continue;
  1021.           case 's':
  1022.             if (tail("subroutine"))
  1023.                 getit();
  1024.             continue;
  1025.           case 'p':
  1026.             if (tail("program")) {
  1027.                 getit();
  1028.                 continue;
  1029.             }
  1030.             if (tail("procedure"))
  1031.                 getit();
  1032.             continue;
  1033.         }
  1034.     }
  1035.     return (pfcnt);
  1036. }
  1037.  
  1038. tail(cp)
  1039.     char *cp;
  1040. {
  1041.     register int len = 0;
  1042.  
  1043.     while (*cp && (*cp&~' ') == ((*(dbp+len))&~' '))
  1044.         cp++, len++;
  1045.     if (*cp == 0) {
  1046.         dbp += len;
  1047.         return (1);
  1048.     }
  1049.     return (0);
  1050. }
  1051.  
  1052. takeprec()
  1053. {
  1054.  
  1055.     while (isspace(*dbp))
  1056.         dbp++;
  1057.     if (*dbp != '*')
  1058.         return;
  1059.     dbp++;
  1060.     while (isspace(*dbp))
  1061.         dbp++;
  1062.     if (!isdigit(*dbp)) {
  1063.         --dbp;        /* force failure */
  1064.         return;
  1065.     }
  1066.     do
  1067.         dbp++;
  1068.     while (isdigit(*dbp));
  1069. }
  1070.  
  1071. getit()
  1072. {
  1073.     register char *cp;
  1074.     char c;
  1075.     char nambuf[BUFSIZ];
  1076.  
  1077.     for (cp = lbuf; *cp; cp++)
  1078.         ;
  1079.     *--cp = 0;    /* zap newline */
  1080.     while (isspace(*dbp))
  1081.         dbp++;
  1082.     if (*dbp == 0 || !isalpha(*dbp))
  1083.         return;
  1084.     for (cp = dbp+1; *cp && (isalpha(*cp) || isdigit(*cp)); cp++)
  1085.         continue;
  1086.     c = cp[0];
  1087.     cp[0] = 0;
  1088.     strcpy(nambuf, dbp);
  1089.     cp[0] = c;
  1090.     pfnote(nambuf, lineno, TRUE);
  1091.     pfcnt++;
  1092. }
  1093.  
  1094. char *
  1095. savestr(cp)
  1096.     char *cp;
  1097. {
  1098.     register int len;
  1099.     register char *dp;
  1100.  
  1101.     len = strlen(cp);
  1102.     dp = (char *)malloc(len+1);
  1103.     strcpy(dp, cp);
  1104.     return (dp);
  1105. }
  1106.  
  1107. /*
  1108.  * Return the ptr in sp at which the character c last
  1109.  * appears; NULL if not found
  1110.  *
  1111.  * Identical to v7 rindex, included for portability.
  1112.  */
  1113.  
  1114. char *
  1115. rindex(sp, c)
  1116. register char *sp, c;
  1117. {
  1118.     register char *r;
  1119.  
  1120.     r = NULL;
  1121.     do {
  1122.         if (*sp == c)
  1123.             r = sp;
  1124.     } while (*sp++);
  1125.     return(r);
  1126. }
  1127.  
  1128. /*
  1129.  * lisp tag functions
  1130.  * just look for (def or (DEF
  1131.  */
  1132.  
  1133. L_funcs (fi)
  1134. FILE *fi;
  1135. {
  1136.     register int    special;
  1137.  
  1138.     pfcnt = 0;
  1139.     while (fgets(lbuf, sizeof(lbuf), fi)) {
  1140.         lineno++;
  1141.         dbp = lbuf;
  1142.         if (dbp[0] == '(' &&
  1143.             (dbp[1] == 'D' || dbp[1] == 'd') &&
  1144.             (dbp[2] == 'E' || dbp[2] == 'e') &&
  1145.             (dbp[3] == 'F' || dbp[3] == 'f')) {
  1146.             dbp += 4;
  1147.             if (striccmp(dbp, "method") == 0 ||
  1148.                 striccmp(dbp, "wrapper") == 0 ||
  1149.                 striccmp(dbp, "whopper") == 0)
  1150.                 special = TRUE;
  1151.             else
  1152.                 special = FALSE;
  1153.             while (!isspace(*dbp))
  1154.                 dbp++;
  1155.             while (isspace(*dbp))
  1156.                 dbp++;
  1157.             L_getit(special);
  1158.         }
  1159.     }
  1160. }
  1161.  
  1162. L_getit(special)
  1163. int    special;
  1164. {
  1165.     register char    *cp;
  1166.     register char    c;
  1167.     char        nambuf[BUFSIZ];
  1168.  
  1169.     for (cp = lbuf; *cp; cp++)
  1170.         continue;
  1171.     *--cp = 0;        /* zap newline */
  1172.     if (*dbp == 0)
  1173.         return;
  1174.     if (special) {
  1175.         if ((cp = index(dbp, ')')) == NULL)
  1176.             return;
  1177.         while (cp >= dbp && *cp != ':')
  1178.             cp--;
  1179.         if (cp < dbp)
  1180.             return;
  1181.         dbp = cp;
  1182.         while (*cp && *cp != ')' && *cp != ' ')
  1183.             cp++;
  1184.     }
  1185.     else
  1186.         for (cp = dbp + 1; *cp && *cp != '(' && *cp != ' '; cp++)
  1187.             continue;
  1188.     c = cp[0];
  1189.     cp[0] = 0;
  1190.     strcpy(nambuf, dbp);
  1191.     cp[0] = c;
  1192.     pfnote(nambuf, lineno,TRUE);
  1193.     pfcnt++;
  1194. }
  1195.  
  1196. /*
  1197.  * striccmp:
  1198.  *    Compare two strings over the length of the second, ignoring
  1199.  *    case distinctions.  If they are the same, return 0.  If they
  1200.  *    are different, return the difference of the first two different
  1201.  *    characters.  It is assumed that the pattern (second string) is
  1202.  *    completely lower case.
  1203.  */
  1204. striccmp(str, pat)
  1205. register char    *str, *pat;
  1206. {
  1207.     register int    c1;
  1208.  
  1209.     while (*pat) {
  1210.         if (isupper(*str))
  1211.             c1 = tolower(*str);
  1212.         else
  1213.             c1 = *str;
  1214.         if (c1 != *pat)
  1215.             return c1 - *pat;
  1216.         pat++;
  1217.         str++;
  1218.     }
  1219.     return 0;
  1220. }
  1221.  
  1222. /*
  1223.  * first_char:
  1224.  *    Return the first non-blank character in the file.  After
  1225.  *    finding it, rewind the input file so we start at the beginning
  1226.  *    again.
  1227.  */
  1228. first_char()
  1229. {
  1230.     register int    c;
  1231.     register long    off;
  1232.  
  1233.     off = ftell(inf);
  1234.     while ((c = getc(inf)) != EOF)
  1235.         if (!isspace(c) && c != '\r') {
  1236.             fseek(inf, off, 0);
  1237.             return c;
  1238.         }
  1239.     fseek(inf, off, 0);
  1240.     return EOF;
  1241. }
  1242.  
  1243. /*
  1244.  * toss_yysec:
  1245.  *    Toss away code until the next "%%" line.
  1246.  */
  1247. toss_yysec()
  1248. {
  1249.     char        buf[BUFSIZ];
  1250.  
  1251.     for (;;) {
  1252.         lineftell = ftell(inf);
  1253.         if (fgets(buf, BUFSIZ, inf) == NULL)
  1254.             return;
  1255.         lineno++;
  1256.         if (strncmp(buf, "%%", 2) == 0)
  1257.             return;
  1258.     }
  1259. }
  1260. SHAR_EOF
  1261. cat << \SHAR_EOF > ctags.uu
  1262.  
  1263. begin 644 ctags
  1264. M```#\P`````````"``````````$```\\```!=@```^D```\\)$@D`$GY````$
  1265. M`"QX``1(Y\#@F?P`````(#P``!38(CP``0`!3J[_.DJ`9P`!LB!`)$`B0"`\/
  1266. M```!:2#<4X!F^B`<9PX@2='<U=`@BB1)4X!@\"A)V?P`````3-\'`RQX``0I+
  1267. M3@7<*4\%Y$*L!>`F;@$4<``B/```,`!.KO[.*6L`F`782JL`K&<``'`@#Y"O!
  1268. M``0&@````(`I0`6H80`!2B!K`*S1R-'((F@`$-/)T\D@`G(`$ADI207LT(%2,
  1269. M@$)G4H`"0/_^G\!5@$)W"``@`E.`U($?L@``(`!3@E'(__8?O``@(`!3@A^Q-
  1270. M(``@`%'*__@B3R\)8```>"EK`#H%J'!_4H#1K`6H80``WD'K`%Q.KOZ`0>L`F
  1271. M7$ZN_HPI0`7@+P`D0"`J`"1G$BQL%-0@0"(H```I00783J[_@B(J`"!G&B0\E
  1272. M```#[4ZN_^(I0`7H9PKEB"!`)V@`"`"D(&P%X"\(2&P%I"!H`"0I:``$!>Q.A
  1273. MNA?N3KH=DG``8`0@+P`$+P`@+`709P0@0$Z03KHN*BQX``0B;!343J[^8DZZX
  1274. M%\1*K`7@9QHB+`7H9P1.KO_<+'@`!$ZN_WPB;`7@3J[^AB`\```4V"),D_P`+
  1275. M````+'@`!$ZN_RX@'RYL!>1.=4S?!P-.=7!D8)A#^@`0<`!.KOW8*4`4U&?L,
  1276. M3G5D;W,N;&EB<F%R>0```$Y5_YB_[`6H90`CXDCG`Q`N+P!\)F\`@&```)Q\0
  1277. M`6```(8@:P`$T<80$$B`<C!=06L``)RP>Q`(9O1.^Q`$`'A@``!>`'9@``!.0
  1278. M`'=@``!"`'5@```V`'1@```J`&%@```>`$9@```0`$)@```"&7P`/P`N8"X9$
  1279. M?``O`"Y@)E*L$'I@(%*L$'Y@&E*L$()@%%*L$(9@#E*L$(I2K!".8`12K!".G
  1280. M4H8@:P`$T<9*$&8`_W)3AUB+<`&^@&\,(&L`!'`ML!!G`/]6<`&^@&X22&P`A
  1281. M[DZZ%O!(>``!3KHSH%!/80``\'`!*4`0=F`4("P0=N6`+S,(`&$``:Y83U*LR
  1282. M$'8@+!!VL(=MY$JL$(YG$"\L$IYA``WX0I=.NC-B6$]*K!""9S)\`5B+8"0@>
  1283. M;``V+P@O&R\(2&P!$DAM_YA.NBC42&W_F$ZZ(L)/[P`84H:\AVW84JP0>DJL=
  1284. M$'IG!D'L`4)@!$'L`40O""\L`#9.NC"*4$\I0!*69A(O+``V3KHJ*DAX``%.K
  1285. MNC+V4$\O+!*>80`-?"ZL$I9.NC*(6$]*K!""9R`@;``V+P@O"$AL`49(;?^8G
  1286. M3KHH7DAM_YA.NB),3^\`%$*G3KHRMDSM",#_C$Y=3G5.5?_TO^P%J&4`(A!("
  1287. MYP$0<``K0/_T<'YR`$'L!W`0P5'(__QP?D'L!O$0P5'(__QP?D'L!G(0P5'(C
  1288. M__QP?D'L!?,0P5'(__QP?G(!0>P'[Q#!4<C__"9L`$!@#A`;2(!![`7S$;P`!
  1289. M`0``2A-F[B9L`&1@#A`;2(!![`9R$;P``0``2A-F[B9L`.)@#A`;2(!![`;QF
  1290. M$;P``0``2A-F[B9L`)Y@#A`;2(!![`=P$;P``0``2A-F[B9L`.I@#!`;2(!!/
  1291. M[`?O0C```$H39O!,WPB`3EU.=;_L!:AE`"%`+PLF;P`(2&P!5"\+3KHO/%!/R
  1292. M*4`2DF8,+PM.NBC>6$]@``$*+PMA`!$"*4`0<D*L"&Y(>``N+PMA`!$B3^\`0
  1293. M#"9`(`MG:'!LL"L``69@2BL``F9:80`3>"\`2&P!5DZZ)<!03TJ`9Q8O+!*29
  1294. M80`1'"ZL$I).NC#\6$]@``"P80`3VF$`"H9(>``!+RP(;DAL`5IA``"<80`3(
  1295. MPF$``;HNK!*23KHPSD_O``Q@``"`(`MG)G!YL"L``68>2BL``F8880`3F&$`O
  1296. M!]9A``&,+RP2DDZZ,*!83V!4(`MG0A`K``%R8[`!9SAR:+`!9S)**P`"9BPO.
  1297. M+!*280`,P%A/2H!G#"\L$I).NC!L6$]@('``+P`O`"\L$I).NBQV3^\`#&$`-
  1298. M`38O+!*23KHP2EA/)E].=4Y5_?R_[`6H90`@!$CG`#`F;P(42'@`'$ZZ*>A8[
  1299. M3R1`(`IF+DAL`6!(;`-43KHMK"ZL$IYA``KX+JP2GF$`"?Y(>``<3KHIO$_O8
  1300. M``PD0"E*$IY*K!".9EQ(;`&"+PM.NB0R4$]*@&9,2'@`+R\L$')A``^Z4$\F.
  1301. M0$J`9@8F;!!R8`)2BR\+2&P!B$AM_?Q.NB6D2'@`+DAM_?QA``^03^\`%"9`3
  1302. M(`MG"$HK``)F`D(31^W]_"\+80`/0EA/)(`E;!!R``05;0`3``@E;0`,``J1?
  1303. MR"5(`!@E2``42JP0CF860BP0Q$AL`8Q(;!"23KHCQ%!/0BP0Q$AL$))A``[^*
  1304. M6$\E0``.2JP2GF8(($HI2!*>8`PO+!*>+PIA``E,4$],WPP`3EU.=4Y5_=R_>
  1305. M[`6H90`>WDCG(S)P`!E`!?(90`7Q?@!'[`AR1>P(<D'L"'(K2/_H4JP(;B\LS
  1306. M$I(;0/_L&T#_[AM`_^T;0/_O3KHJ=EA/*4`2FB!L$I)3J``(;1HB;!*2(&D`;
  1307. M!$WH``$B;!*2(TX`!'``$!!@"B\L$I).NAR06$\L`"!M_^@0@")L$I((*0`$,
  1308. M`!MF``,N<`J\@&8(4JP(;F```?YP7+R`9E!#Z``!*TG_Z"!L$I)3J``(;1HB*
  1309. M;!*2(&D`!$/H``$L;!*2+4D`!'``$!!@"B\L$I).NAPP6$\@;?_H$(`L`$B&Q
  1310. M2,9P"KR`9@`!KGP@8``!J$HM_^]G9'`JO(!F``&:4JW_Z"!L$I)3J``(;1HB'
  1311. M;!*2(&D`!$WH``$B;!*2(TX`!'``$!!@"B\L$I).NAO66$\L`"!M_^@0@'(J?
  1312. ML`%GP'`*O(!F!%*L"&YP+[R`9@`!2'``&T#_[V```3Y*+?_N9Q)P(KR`9@#^=
  1313. MXG``&T#_[F``_MA*+?_M9Q!P)[R`9@#^RD(M_^U@`/["(`9R,`1!``AK``$$K
  1314. ML+L0"&;R3OL0!@```'U@``#&````>V```*H````C8```B@```"]@```F````D
  1315. M)V```!0````B8````AM\``'_[F``_G(;?``!_^U@`/YH4JW_Z"!L$I)3J``(7
  1316. M;1HB;!*2(&D`!$WH``$B;!*2(TX`!'``$!!@"B\L$I).NAKR6$\@;?_H$(!R-
  1317. M*K`!9@H;?``!_^]@`/X@2(!(P"\L$I(O`$ZZ%4A03V``_@Q![`AR(FW_Z+/(3
  1318. M9@#]_AE\``$%\6``_?1P`;"L`"IF!G("*4$`*E*'8`#]X$'L"'(B;?_HL\AF]
  1319. M!'X`8`)3ATJ'9@#]R'`"L*P`*F8`_;YP`RE``"I@`/VT2H=F``#`2BW_[F8`K
  1320. M`+A*+?_O9@``L!`L!?)F``"H2BW_[&<``(I![`9R2C!H`&=P("P(;DAM_>0OL
  1321. M"B\+2&W_Z"]``"AA``#D3^\`$$J`9T8@"B(+D($D`%*"+P(O`4AM_>@O0``HS
  1322. M3KH?>"`O`"A![?WIT<!"$&$`!:`NK?WD+R\`)$AM_>AA`/NV3^\`%"`M_>096
  1323. M0`7R0BW_["9M_^A@)$'L!O%*,&@`9QI2BF`60>P'<$HP:`!G#"1M_^@F2AM\@
  1324. M``'_['`[O(!F#'`#L*P`*F8$0JP`*E*M_^AP"KR`9PY![`YR(FW_Z+/(8P#\.
  1325. MQD'L"'(K2/_H)D@D2"\L$I).NB<@6$\I0!*:<``90`7R&4`%\1M`_^P;0/_N(
  1326. M&T#_[6``_)),WTS$3EU.=4Y5__:_[`6H90`;&$CG`S(F;P`J<`$@;0`4((`@;
  1327. M;0`()%`<$GX`2BP%\69:8$A2BB!L$I)3J``(;1HB;!*2(&D`!$WH``$B;!*2F
  1328. M(TX`!'``$!!@"B\L$I).NACH6$\L`!2&<`J\`&8.4JP(;D'L#G*UR&(``;P0:
  1329. M!DB`0>P%\THP``!FJF`V2'@`!DAL`8XO"TZZ'DA/[P`,2H!F"'``&4`%\&`$H
  1330. M4BP%\`PL``(%\&T,&7P``07R?@%@``%V2JP0?F<>2'@`!TAL`98O"TZZ'@Q/4
  1331. M[P`,2H!F"'`!*4``*F#6<`&PK``J9D)(>``&2&P!GB\+3KH=YD_O``Q*@&>X=
  1332. M2'@`!4AL`:8O"TZZ'=!/[P`,2H!GHDAX``1(;`&L+PM.NAVZ3^\`#$J`9XQPA
  1333. M`;"L`"IF"G`#*4``*F``_WQP`["L`"IF"B!M`!1"D&```.1P*+P`9@#_8D(M"
  1334. M__9@1'`*O`!F#E*L"&Y![`YRM<AB``#"$`9(@$'L!W!*,```9@9P+[P`9@92&
  1335. M+?_V8!80!DB`0>P%\THP``!F"$HM__9G`/\84HH@;!*24Z@`"&T:(FP2DB!I^
  1336. M``1-Z``!(FP2DB-.``1P`!`08`HO+!*23KH7=EA/+``4AG`IO`!F@F`2<`J\!
  1337. M`&8,4JP(;D'L#G*UR&)"4HH@;!*24Z@`"&T:(FP2DB!I``1-Z``!(FP2DB-.B
  1338. M``1P`!`08`HO+!*23KH7*%A/+``4AA`&2(!![`7S2C```&:L($I3B")M``@B^
  1339. MB'`*O`!F!%.L"&X@!DB`2,`O+!*2+P!.NA%L4$]*AV8:(&T`%$J09PX0!DB`$
  1340. M0>P'[THP``!G!'(!8`)R`"`!3-],P$Y=3G5.5?WRO^P%J&4`&)A(YP<P?@!A9
  1341. M``):2'@``2\L"&Y(;`&R80#X<$_O``Q@``'*1^P(<F```;P0$TB`<DY=06L`1
  1342. M`-"P>Q`(9O1.^Q`$`#M@``"Z`'Q@``"T`"5@``"6`'U@``"*`'M@``!^`"]@9
  1343. M``!<`"=@``!"`")@```H``U@``%N``Q@``%H``E@``%B`"!@``%<``I@```"5
  1344. M4JP(;F```4Y2BW`BL!-F^'!<L"O__V?P8``!.E*+<">P$V;X<%RP*___9_!@[
  1345. M``$F4HMP*K`39@XO"V$``4)83R9`8``!$%.+8``!"E*'8``!!%.'8```_G`E%
  1346. ML"L``68``/1![`ARM\AF``#J8``!"'P`8```X$J'9@``VDH&9@``U!`32(!(?
  1347. MP'(#0>P$G<(P"`!F$!`3<BZP`6<(<E^P`68``+(D2U*+8`)2BQ`32(!(P'('G
  1348. M0>P$G<(P"`!F[!`3<E^P`6?D<BZP`6?>(`LB"I"!*@!@`E*+$!-(@$C`0>P$5
  1349. MG0@P``,(`&;L$!-R.K`!9PY*`&9<80`)H'(ZL(%F4B`%2(!(P"\`+PI(;?WR3
  1350. M3KH:C!`%2(!![?WRT,!"$$AL"')(;!"23KH;5$AL$)).NALX0>P0D4(P"`!(&
  1351. M>``!+RP(;DAM_?)A`/:R3^\`)'P!8`)3BU*+2A-F`/Y"+RP2DDAX"`!(;`ARK
  1352. M3KHF;D_O``Q*@&8`_B!,WPS@3EU.=;_L!:AE`!:$+PLF;P`(8!`0*P`!4HMRB
  1353. M+[`!9@0@"V`R2'@`*B\+3KH;1%!/)D!*@&;>1^P(<E*L"&XO+!*22'@(`$AL!
  1354. M"').NB823^\`#$J`9LXF7TYUO^P%J&4`%BY(YP$0+RP2DDZZ(?8N`$*7+RP2=
  1355. MFB\L$I).NB)B+JP2DDAX`@!(;!"23KHETDAX``I(;!"280`&%$_O`!PF0"`+`
  1356. M9P)"$T*G+P<O+!*23KHB+D_O``Q,WPB`3G6_[`6H90`5S"\+)F\`"&`2+RL`U
  1357. M&&'J+HM.NB*,6$\F:P`4(`MFZB9?3G6_[`6H90`5HDCG`3`F;P`0)&\`%"\2"
  1358. M+Q-.NAH24$\N`$J'9F@@:P`$(FH`!+/(9BY*K!"&9@``C"\3+RP(;B\(2&P!-
  1359. MNDAL`U1.NB,J2&P!Y$AL`U1.NB,>3^\`'&!D2BH`$F8@2JP0AF8:+Q,O*@`$<
  1360. M+RL`!$AL`?I(;`-43KHB]D_O`!05?``!`!)@-DJ':AI*J@`49PXO*@`4+PMA>
  1361. M`/]B4$]@'B5+`!1@&$JJ`!AG#B\J`!@O"V$`_TA03V`$)4L`&$S?#(!.=;_L^
  1362. M!:AE`!3:2.<`,B9O`!`@"V<``4`O*P`48>183TJL$(YF``#<2BL`"&<``+@0U
  1363. M+``N2(!(P"\`+RL`!"\32&P",B\L$I9.NB)D3^\`%"1K``Y@<'!<L!)F$$ALI
  1364. M`CPO+!*63KHB2%!/8%@0+``N$A*R`&882(!(P"\`2&P"0"\L$I9.NB(H3^\`0
  1365. M#&`V(&P2EE.H``QM&B)L$I8@:0`$0^@``2QL$I8M20`$$!(0@&`2$!)R`!(`7
  1366. M+RP2EB\!3KH/IE!/4HI*$F:,$"P`+DB`2,`O`$AL`D0O+!*63KHAT$_O``Q@"
  1367. M9B\K``HO*P`$+Q-(;`)(+RP2EDZZ(;1/[P`48$I*K!"*9R9P/]"K``IR0$ZZ/
  1368. M)]`O`"\K``0O$TAL`E)(;`,R3KHAB$_O`!1@'B\K``XO*P`$+RL`"B\32&P":
  1369. M7$AL`S).NB%H3^\`&"\K`!AA`/ZP6$],WTP`3G6_[`6H90`3@"\+)F\`"$*LC
  1370. M$J)@``'&4JP(;D'L$)(I2`)P$"P0DG(EL`%F#D'L$),I2`)P8`12K`)P(&P"P
  1371. M<!`02(!(P$'L!)T(,``#"`!FYB!L`G`0$&<``8)(@$C``$``('(H!$$`"&L`'
  1372. M`.2PNQ`(9O).^Q`&````9&```(@```!C8```7@```&Q@``!"````<F```"(`-
  1373. M``!I8````DAL`G1A``%66$]*@&<``*)A``&,8```FDAL`GQA``$^6$]*@&<`Y
  1374. M`(IA``%T8```@DAL`H)A``$F6$]*@&=R80`!7F!L2&P"BF$``1)83TJ`9@Y(Y
  1375. M;`*280`!!%A/2H!G4&$``3Q@2DAL`IQA``#P6$]*@&<\8`12K`)P(&P"<!`0_
  1376. M2(!(P$'L!)T(,``#"`!FYB!L`G`0$&<``*1(;`*D80``O%A/2H!G``"48`12O
  1377. MK`)P(&P"<!`02(!(P$'L!)T(,``#"`!FYB!L`G`0$&=N2(!(P`!``"`,@```8
  1378. M`'!G.`R`````<V<<#(````!F9DY(;`*N80``:%A/2H!G0&$``29@.DAL`KAAM
  1379. M``!46$]*@&<L80`!$F`F2&P"Q&$``$!83TJ`9P9A``#^8!)(;`+,80``+%A/2
  1380. M2H!G!&$``.HO"TAX`@!(;!"23KHA<$_O``Q*@&8`_B8@+!*B)E].=;_L!:AE.
  1381. M`!&&2.<!$"9O``Q^`&`$4HM2ATH39Q(@;`)PT<=PW\`0<M_"$[(`9^9*$V8(+
  1382. MWZP"<'`!8`)P`$S?"(!.=;_L!:AE`!%$+PM@!%*L`G`@;`)P$!!(@$C`0>P$U
  1383. MG0@P``,(`&;F(&P"<!`0<BJP`6900^@``2E)`G!@!%*L`G`@;`)P$!!(@$C`?
  1384. M0>P$G-'`)D@(*P`#``%FX@@K``(``68&4ZP"<&`:4JP"<"!L`G`0$$B`2,!!W
  1385. M[`2="#```@@`9N8F7TYU3E7]^K_L!:AE`!"Z+PM'[!"28`)2BTH39OI"*___Z
  1386. M8`12K`)P(&P"<!`02(!(P$'L!)S1P"9(""L``P`!9N(@;`)P$!!*`&=@<`/`O
  1387. M*P`!9UA'Z``!8`)2BTH39R`0$TB`2,!R`T'L!)W",`@`2@%FYD'L!)T(,``"-
  1388. M"`!FVA`30A,O+`)P2&W]_!]```Q.NA2J%J\`#$AX``$O+`AN2&W]_&$`\!12T
  1389. MK!*B)FW]]DY=3G5.5?_\O^P%J&4`$`HO+0`(3KH48E*`+H!.NAGN+JT`""\`,
  1390. M+T``"$ZZ%&`@+P`(3EU.=;_L!:AE``_<2.<!,"9O`!`>+P`7E<H0$[`'9@(D.
  1391. M2R!+4HM*$&;P(`I,WPR`3G6_[`6H90`/KDCG`1`F;P`,0JP2HF```-)2K`AN*
  1392. M0>P0DBE(`G`0+!"2<BBP`68``+H0+!"3<D2P`6<(<F2P`68``*@0+!"4<D6P,
  1393. M`6<(<F6P`68``)80+!"5<D:P`6<(<F:P`68``(1![!"6*4@"<$AL`M8O"&$`Z
  1394. M`5903TJ`9R1(;`+>+RP"<&$``4103TJ`9Q)(;`+F+RP"<&$``3)03TJ`9@1^"
  1395. M`6`(?@!@!%*L`G`@;`)P$!!(@$C`0>P$G0@P``,(`&?F8`12K`)P(&P"<!`0Y
  1396. M2(!(P$'L!)T(,``#"`!FYB\'80``(EA/+PM(>`(`2&P0DDZZ'I!/[P`,2H!F/
  1397. M`/\:3-\(@$YU3E7]^K_L!:AE``ZD+PM'[!"28`)2BTH39OIP`!=`__\@;`)PF
  1398. M$A!*`6<``)1*K0`(9T1(>``I+PA.NA-64$\F0$J`9@1@>%.+M^P"<&4&<#JPL
  1399. M$V;RM^P"<&5D*4L"<&`"4HM*$V<L$!-R*;`!9R1R(+`!9NQ@'"9L`G!2BV`"L
  1400. M4HM*$V<.$!-R*+`!9P9R(+`!9NP0$T(3+RP"<$AM_?P?0``,3KH2?A:O``Q(N
  1401. M>``!+RP(;DAM_?QA`.WH4JP2HB9M_?9.74YUO^P%J&4`#>)(YP$P)F\`$"1O8
  1402. M`!1@5A`32(!(P$'L!)T(,```"`!G(D'L!)T(,```"`!G#!`32(!(P'(@T(%@+
  1403. M!A`32(!(P"X`8`8>$TB'2,<0$DB`2,"PAV<.$!)(@$C`(@>2@"`!8`I2BE*+K
  1404. M2A)FIG``3-\,@$YUO^P%J&4`#6I(YP,@+RP2DDZZ&3)83RX`8"9![`2="#``+
  1405. M`V@`9AIP#;R`9Q1"IR\'+RP2DDZZ&8I/[P`,(`9@1B!L$I)3J``(;1HB;!*2J
  1406. M(&D`!$7H``$B;!*2(TH`!'``$!!@"B\L$I).N@LF6$\L`%*`9J9"IR\'+RP2-
  1407. MDDZZ&4)/[P`,</],WP3`3G5.5?X`O^P%J&4`#-HO+!*23KH8IBE`$IHNK!*2\
  1408. M2'@"`$AM_@!.NAR.3^\`#$J`9QQ2K`AN2'@``DAL`NY(;?X`3KH06D_O``Q*1
  1409. M@&;`3EU.=4YU3G5(YP<P+B\`&"9O`!PL+P`@+P=.NB*T6$\D0"`*9@1P_V`V9
  1410. M""H``P`#9Q!(>``"0J<O!TZZ%J!/[P`,+P8O"R\J``1.NATP3^\`#"H`2JP%H
  1411. MO&<$</]@`B`%3-\,X$YU``````````!P84CG`Q`F;P`0($M*&&;\4XB1RRP()
  1412. M?@`>&TJ'9S)3K`,^;18@;`,V0^@``2E)`S8@!Q"`<@`2`&#<(`=R`!(`2&P#9
  1413. M,B\!3KH'9E!/(@!@QDAL`S)(>/__3KH'5%!/(`9,WPC`3G4```````!P84Y5W
  1414. M_\1(YR<P)F\`7"1O`&!^`'P`>@!P`!M\`"#_^W(`*T'_]G3_*T+_\D'M_]`;^
  1415. M0/_Q&T#__"M!_^0K0?_H*TC_S$H39T)P`!`3<AA=06LXL'L0"&;V3OL0!``CI
  1416. M8```(``@8```%@`K8```#``M8````GX!8`Y\`6`*>@%@!AM\``'__%*+8+H0+
  1417. M$W(PL`%F!E*+&T'_^W`JL!-F$"!20^@`!"2)*U#_]E*+8`Y(;?_V+PM.NA#(E
  1418. M4$_7P!`3<BZP`68F4HMP*K`39A`@4D/H``0DB2M0__)2BV`.2&W_\B\+3KH0C
  1419. MFE!/U\`0$W)LL`%F"AM\``'_\5*+8`AR:+`!9@)2BQ`;<@`2`!M`__!P,%U`%
  1420. M:P`"5+)[``AF]$[[``0`8V```BH`<V```>@`6&```7X`>&```7@`<&```5X`_
  1421. M;V```0P`=6```.(`9&````)*+?_Q9PP@4D/H``0DB2`08`H@4D/H``0DB2`09
  1422. M*T#_[&P*<@%$K?_L*T'_Z$JM_^AG!'`M8`I*!F<$<"M@`G`@&T#_T'``$`8B8
  1423. M+?_H@H!P`!`%@H!G"%*M_\Q2K?_D+RW_["\M_\Q.N@\J4$\K0/_(("W_\DJ``
  1424. M:@9R`2M!__(@+?_((BW_\I*`2.T``O_$;RX@;?_,(DC3P6`"$MA3@&3Z<``00
  1425. M+?_[(BW_Q"!M_\Q@`A#`4X%D^B`M__(K0/_(T:W_Y$'M_]`K2/_,2@=G``%0*
  1426. M&WP`(/_[8``!1DHM__%G#"!20^@`!"2)(!!@"B!20^@`!"2)(!`K0/_L8`#_-
  1427. M8DHM__%G#"!20^@`!"2)(!!@"B!20^@`!"2)(!`K0/_L2BW__&<2(&W_S!#\'
  1428. M`#!R`2M!_^0K2/_,+P`O+?_,3KH.A%!/*T#_R&``_R@;?``P__L@+?_R2H!JK
  1429. M!G`(*T#_\DHM__%G#"!20^@`!"2)(!!@"B!20^@`!"2)(!`K0/_L2BW__&<6?
  1430. M(&W_S!#\`#`0_`!X<@(K0?_D*TC_S"\`+RW_S$ZZ#F!03RM`_\AP6+`M__!FP
  1431. M`/Z^2&W_T$ZZ#`183V``_K`@4D/H``0DB2)0*TG_S&8(0?H`W"M(_\P@;?_,G
  1432. M2AAF_%.(D>W_S"M(_^0@+?_R2H!K*K'`;R8K0/_D8"!P`2M`_^0@4D/H``0DS
  1433. MB2`0&T#_T$(M_]%@!G``8```C"`M_^0B+?_VLH!L"'0`*T+_]F`$D:W_]DH'\
  1434. M9S93K?_D;1AP`"!M_\P0&"\`*TC_S"!M`!!.D%A/8.)3K?_V;4AP`!`M__LO&
  1435. M`"!M`!!.D%A/8.A3K?_V;1)P`!`M__LO`"!M`!!.D%A/8.A3K?_D;1AP`"!M#
  1436. M_\P0&"\`*TC_S"!M`!!.D%A/8.(@"TS?#.1.74YU``!.5?_V2.<!,"9O`!XD'
  1437. M;P`B*VT`$/_V'AI*!V<T<"6^`&8BL!)F!%**8!HO"TAM__8O"F$`^\Q/[P`,^
  1438. M*T#_^F<$)$!@TG``$`<O`$Z36$]@QDS?#(!.74YU2.<A$"XO`!`F;P`4</^^1
  1439. M@&=@""L````;9UAR,,*K`!A*@69.""L``@`;9Q@B!Q=!`"!!ZP`@)T@`!'0!>
  1440. M)T(`""`!8"X@:P`$(FL`$+/(9@1P_V`>4ZL`!"!K``0@!Q"`""L`!P`:9P93Z
  1441. MJP`(8`12JP`(3-\(A$YU3E7_\$CG(3(F;P`L#*P````@%")L``"&$!-R(+`!1
  1442. M9PQR";`!9P9R"K`!9@12BV#H2A-G:"`L%"+E@%*L%")![!0JT<`D2'`BL!-FR
  1443. M)E*+)(M*$V<*<"*P$V<$4HM@\DH39@Q(>``!3KH&+%A/8)Y"&V":)(M*$V<8`
  1444. M$!-R(+`!9Q!R";`!9PIR"K`!9P12BV#D2A-F`F`&0AM@`/]R2JP4(F8&(&P%U
  1445. MX&`$0>P4*BE(%"9*K!0B9GQ!^@$D0^P3Z"+8(M@BV"+8,I`B;`7@(&D`)$AX\
  1446. M`"@O*``$2&P3Z$ZZ"A9/[P`,0>P3Z"(()#P```/N+&P4U$ZN_^(I0!*L*4`2&
  1447. MM'($*4$2L"E`$KPI01*XY8"3R2QX``0K0/_P3J[^VB!M__`B0"-H``@`I'X`K
  1448. M*T#_]&`J+&P4U$ZN_\HI0!*L3J[_Q"E`$K1!^@"F(@@D/````^U.KO_B*4`2U
  1449. MO'X$(`<`0(`!@:P2J"`'`$"``H&L$K``K```@`,2N$JL`WAG!'``8`8@/```L
  1450. M@``N`$*L`RP@!P!```$I0`,H<`$I0`-.(`<`0``"*4`#2G`"*4`#<"`'`$``&
  1451. M@"E``VQ!^AGV*4@%U"\L%"8O+!0B3KKA-D*73KH5K$SM3(3_W$Y=3G5C;VXZ?
  1452. M,3`O,3`O,S(P+S@P+P`J````````````````````````````````````````E
  1453. M`'!A+PLF;P`(2JL`%&<,""L``P`;9@1P`&`V+RP%H$ZZ$'Y83R=```0G0``0$
  1454. M2H!F"G`,*4`4T'#_8!8G;`6@`!1P\\&K`!AP`"=```PG0``()E].=0``````U
  1455. M````````````3E7_[$CG+Q`N+P`T)F\`."@'<#'`JP`89P9P_V```G`(*P`'5
  1456. M`!I6P$0`2(!(P"P`2JL`%&8``(0(*P`"`!MF>G``)T``#'+_OH%G``)"+PM.9
  1457. MNO].6$]*@&<,".L`!0`;</]@``(J".L``0`;2@9G#B`K`!0B`$2!)T$`#&`(O
  1458. M("L`%"=```Q3JP`,;18@:P`$0^@``2=)``0@!Q"`<@`2`&`2(`=R`!(`+PLO/
  1459. M`6$`_U)03R(`(`%@``'6""L``@`;9UAP_[Z`9@9P`&```<(@!QM`__]*!F<B@
  1460. M<@J^@68<<@(O`4AZ`;(O*P`<*T'_\$ZZ]OQ/[P`,*@!@&G(!+P%(;?__+RL`_
  1461. M'"M!__!.NO;@3^\`#"H`?O]@``#@".L``0`;2@9G4G#_OH!G3%2K``QR"KZ!$
  1462. M9B8@:P`$0^@``2=)``00O``-(BL`#$J!:PHO"R\`80#^KE!/4JL`#"!K``1#=
  1463. MZ``!)TD`!"`'$(`B*P`,2H%K``$<?O\@*P`$D*L`$"M`__!G<@@K``8`&F=26
  1464. M2'@``D*G+RL`'$ZZ#2A/[P`,*T#_[$H&9SA3K?_L;3)"IR\M_^PO*P`<3KH-R
  1465. M"$AX``%(;?_]+RL`'$ZZ"BA/[P`82JP%O&8*$"W__7(:L`%GR"\M__`O*P`0!
  1466. M+RL`'$ZZ]@!/[P`,*@!@`GH`</^Z@&8(".L`!0`;8`RZK?_P9P8(ZP`$`!M*Y
  1467. M!F<.(BL`%"0!1((G0@`,8!@(*P`"`!MG"'(`)T$`#&`((BL`%"=!``P@:P`0Q
  1468. M)T@`!+Z`9RY3JP`,;18@:P`$0^@``2=)``0@!Q"`<@`2`&`2(`=R`!(`+PLO#
  1469. M`6$`_9!03R(`<##`JP`89P1P_V`,</^X@&8$<`!@`B`$3-\(]$Y=3G4-"@``,
  1470. M``!(YP<0)F\`%`@K``<`&E;`1`!(@$C`+@!P,,"K`!AG"D*K``AP_V```5@(4
  1471. M*P`'`!MG%`@K``8`&V<,+PM(>/__3KK](E!/2JL`%&8V0JL`"`@K``(`&V<2P
  1472. M<`$G0``40>L`("=(`!!@``"$+PM.NOR66$]*@&=V".L`!0`;</]@``$`2@=G8
  1473. M9E2K``@@*P`(2H!N6B!K``1#Z``!)TD`!'P`'!`@!@R`````&F<N#(`````-C
  1474. M9C)3JP`(;10@:P`$0^@``2=)``1P`!`08```M"\+80#_+EA/8```J`CK``0`@
  1475. M&W#_8```G"`&8```E@@K``$`&V9.".L````;+RL`%"\K`!`O*P`<3KH(3$_O;
  1476. M``PJ`$J%:@8(ZP`%`!M*A68&".L`!``;2H5O&DH'9PH@!42`)T``"&`$)T4`7
  1477. M""!K`!`G2``$<#+`JP`89Q9*!V<(</\G0``(8`9P`"=```AP_V`@4ZL`"&T2/
  1478. M(&L`!$/H``$G20`$<``0$&`(+PMA`/Z$6$],WPC@3G4``$CG!P`N+P`0+"P"^
  1479. M]$I&:S`@!DC`YX!![!*H*C`(`$H%9QH(!0`"9A0@!DC`YX!![!*H+S`(!$ZZ%
  1480. M$RQ83U-&8,PO!TZZVYQ83TS?`.!.=0``````````<&$N;`7D3KH3)DAY````K
  1481. M%$ZZ$(```````````'!A2.<W$"9O`!QZ`"QL%-1.KO_$+@!*AV840?H`3"(('
  1482. M)#P```/N3J[_XBX`>@$B"W0`)@=.KO\B+`!*A6<&(@=.KO_<2H9F%G#_*4`4B
  1483. MT"QL%-1.KO]\*4`%O'#_8`1.KO]\3-\([$YU3DE,.@``56YK;F]W;B!E<G)O"
  1484. M<B!C;V1E``!5<V5R(&ES(&YO="!O=VYE<@!.;R!S=6-H(&9I;&4@;W(@9&ERT
  1485. M96-T;W)Y`$YO('-U8V@@<')O8V5S<P!);G1E<G)U<'1E9"!S>7-T96T@8V%LP
  1486. M;`!)+T\@97)R;W(`3F\@<W5C:"!D979I8V4@;W(@861D<F5S<P!!<F<@;&ESF
  1487. M="!I<R!T;V\@;&]N9P``17AE8R!F;W)M870@97)R;W(`0F%D(&9I;&4@;G5MA
  1488. M8F5R`$YO(&-H:6QD('!R;V-E<W,``$YO(&UO<F4@<')O8V5S<V5S(&%L;&]W_
  1489. M960`3F\@;65M;W)Y(&%V86EL86)L90!!8V-E<W,@9&5N:65D`$)A9"!A9&1R=
  1490. M97-S`$)U;&L@9&5V:6-E(')E<75I<F5D``!297-O=7)C92!I<R!B=7-Y``!&7
  1491. M:6QE(&%L<F5A9'D@97AI<W1S`$-R;W-S+61E=FEC92!L:6YK`$YO('-U8V@@A
  1492. M9&5V:6-E``!.;W0@82!D:7)E8W1O<GD`27,@82!D:7)E8W1O<GD``$EN=F%L#
  1493. M:60@87)G=6UE;G0``$YO(&UO<F4@9FEL97,@*'5N:71S*2!A;&QO=V5D`$YO\
  1494. M(&UO<F4@9FEL97,@*'5N:71S*2!A;&QO=V5D(&9O<B!T:&ES('!R;V-E<W,`0
  1495. M`$YO="!A('1E<FUI;F%L``!497AT(&9I;&4@:7,@8G5S>0!&:6QE(&ES('1OQ
  1496. M;R!L87)G90!.;R!S<&%C92!L969T`%-E96L@:7-S=65D('1O('!I<&4`4F5AL
  1497. M9"UO;FQY(&9I;&4@<WES=&5M`%1O;R!M86YY(&QI;FMS``!"<F]K96X@<&EPJ
  1498. M90!-871H(&9U;F-T:6]N(&%R9W5M96YT(&5R<F]R``!-871H(&9U;F-T:6]N2
  1499. M(')E<W5L="!I<R!O=70@;V8@<F%N9V4``$CG(#`F;P`0)$M*$F<D<``0$D'L.
  1500. M!)T(,``!"`!G"G(`$@!T()*"8`1R`!(`%(%2BF#8(`M,WPP$3G4`````````Y
  1501. M`'!A(F\`""!O``0@+P`,(@A@!!#99PA3@&3X8`9"&%.`9/H@`4YU2.<#,"9OY
  1502. M`!0D;P`8+B\`'$J'9R!*$V<<2A)G&'``$!MR`!(:D($L`$J&9P0@!F`:4X=@6
  1503. MW$J'9Q!*$V<$<`%@"DH29P1P_V`"<`!,WPS`3G5.5?_X2.<#,"9O`"`D;P`DQ
  1504. M+B\`*"!*2AAF_%.(D<HL""!+2AAF_%.(D<L@"")+T\`K2?_XO(=C`BP'(`8@W
  1505. M2F`"$MA3@&3Z(&W_^$(P:``@"TS?#,!.74YU(&\`!"`(2AAF_%-(D<`@"$YU+
  1506. M```@;P`((F\`!"`)$MAF_$YU(&\`!")O``@2&+(99@A*`6;V<`!.=6X$</].\
  1507. M=7`!3G4B;P`((&\`!"`(2AAF_%.($-EF_$YU``!(YP$0)F\`#"XO`!!P`!`3+
  1508. ML(=F!"`+8`@0&TH`9NYP`$S?"(!.=4CG`1`F;P`,+B\`$"\'+PMAR%!/3-\(<
  1509. M@$YU2.<!,"9O`!`N+P`4E<I*$V<.<``0$["'9@(D2U*+8.X@"DS?#(!.=2`OI
  1510. M``@@;P`$3E7_]")/<@I.N@[\!D$`,!+!2H!F\"`)$.&_R6;Z0A"0CTY=3G4`[
  1511. M`"`O``@@;P`$3E7_]")/(@`"00`'!D$`,!+!YHAF\"`)$.&_R6;Z0A"0CTY=)
  1512. M3G4``#`Q,C,T-38W.#EA8F-D968@+P`((&\`!$/O``0R``)!``\2^Q#<Z(AF8
  1513. M\B`)(@]8@1#ALHEF^D(0D(%.=2!O``0B2'(`<``O`@P0`"MG!@P0`"UF`E)(F
  1514. M$!@$```P;1(,```);@PD`>6!TH+2@=*`8.8,$0`M9@)$@20?(`A3@"!O``@@@
  1515. M@9")3G4O!RXO``A2K!2P(`<@;!2L$,`I2!2L+A].=4Y5``!(YP`P)F\`$"1OX
  1516. M`!1"K!2P*4L4K$AM`!`O"DAZ_\9.NO'Z(&P4K$(0("P4L$SM#`#_^$Y=3G5.8
  1517. M5?_H2.<!,BXO`#1*AVX&</]@``#2<`B^@&0"+@`@!U:`+@`"1__\)&T`""!MT
  1518. M``C1Q]^L`PA#[`,$)E$K2/_P*TG_]"`+9P``D"!+("L`!-'`*TC_[")M__"WL
  1519. MR6,0)(LE1P`$+&W_]"R*<`!@>+?)9AHL4R2.("L`!"(`TH<E00`$+&W_]"R*,
  1520. M<`!@6K7(9`B?K`,(</]@3K7(9BQ*DV<.(%.SR&,(GZP#"'#_8#C?JP`$2I-GO
  1521. M#K/39@H@*0`$T:L`!":1<`!@'BM+__0K;?_L_^@F4V``_VX@;?_T((I"DB5'Y
  1522. M``1P`$S?3(!.74YU``````````!P84CG`1`F;P`,+B\`$"\'+PM.NO[V4$],/
  1523. MWPB`3G5(YP<P+B\`&"9O`!PL+P`@+P=.N@ZP6$\D0"`*9@1P_V`>+P8O"R\J!
  1524. M``1.N@H,3^\`#"H`2JP%O&<$</]@`B`%3-\,X$YU``!(YP$0)F\`#$JL%-!GJ
  1525. M6"`L%-"PK`-\;@)L!'X`8`(N`$AL`U1(>``*3KH%1DAL`U0O"TZZ!0Q(;`-4B
  1526. M2'H`-$ZZ!0`@!^6`2&P#5$'L`X`O,`@`3KH$[$AL`U1(>``*3KH%$$_O`"@@A
  1527. M+!303-\(@$YU.B```````````````````$Y5_^9(YP\P)F\`.BXO`#Y"+?__M
  1528. M0JP%O"ML%-#_\GH#NJP"]&P2(`7G@$'L$JA*L`@`9P12A6#H("P"]+"%9@QP*
  1529. M&"E`%-!P_V```2H@!>>`0>P2J-'`)$A*K0`09P@(+0`"`!-G"BM\```#[/_N#
  1530. M8`@K?````^[_[B`\``"``,"L`PRQAP@'``-G#"`'`D#__"X``$<``B`'<@/`X
  1531. M@0R``````F<,#(`````!9P1*@&8&+`=2AF`,<!8I0!30</]@``"T(`<"@```F
  1532. M`P!G``"("`<`"F<6&WP``?__+RW_[B\+3KH)(E!/*`!@/`@'``EF%DAX`^TOJ
  1533. M"TZZ",103R@`2H1J!`C'``D(!P`)9QH;?``!__\I;?_R%-`O+?_N+PM.N@E(P
  1534. M4$\H`$HM__]G-B`'<GC2@<"!2H!G*DJ$:R8O!$ZZ"9!(>`/M+PM.N@AR3^\`V
  1535. M#"@`8`Y(>`/M+PM.N@A@4$\H`$JL!;QG!'#_8`@DAB5$``0@!4S?#/!.74YU-
  1536. M````````````````2.<`,B9L%+0@"V<4)%,B2R`K``@L>``$3J[_+B9*8.B1R
  1537. MR"E(%+@I2!2T3-],`$YU2.<!,"XO`!!*K!3`9Q8D;!3`+Q(O+!3`3KK]2E!/.
  1538. MD<@I2!3`2H=F!'``8!Y8AR\'3KH!FEA/)D!*@&8$<`!@"B1+)(=!ZP`$(`A,8
  1539. MWPR`3G5(YP\0+B\`&"PO`!PJ+P`@+P=.N@O@6$\F0"`+9@1P_V`>+P4O!B\K<
  1540. M``1.N@;`3^\`#"@`2JP%O&<$</]@`B`$3-\(\$YU``!(YP$R+B\`%'`,WH`@.
  1541. M!W(`+'@`!$ZN_SHF0"`+9@1P`&`Z)T<`"$7L%+0@:@`$)T@`!)'()HA*DF8"6
  1542. M)(M*J@`$9P8B:@`$(HLE2P`$2JP"^&8$*4L"^$'K``P@"$S?3(!.=0``````G
  1543. M````````````2.<#,"XO`!1*AVX&<`!@``"D<`B^@&0"+@`@!U:`+@`"1__\%
  1544. M1>P#!"92(`MG0"`K``2PAVTRL(=F#"!3)(B?K`,((`M@;B`K``20AW((L(%ET
  1545. M%B!+T<<DB"1()),E0``$GZP#""`+8$PD2R938+P@!R(L!`S0@5.`3KH(BB(L3
  1546. M!`Q.N@AB+`!0AB`&5H`L``)&__PO!DZZ_OI83R9`(`MG$B\&+PM.NOJ^+H=A:
  1547. M`/]44$]@`G``3-\,P$YU``````````!P82\'+B\`""\'3KK_,EA/+A].=0``0
  1548. M2.<!$"9O``P(*P`!`!MG%DJK`!1F!'``8%PO"TAX__].NN^.4$](>``!0J<O!
  1549. M*P`<3KK^/D_O``PN`'#_OH!G!DJK`!1F!"`'8"P(*P`!`!MG#"`K``20JP`0?
  1550. MT(=@&`@K``<`&F<*(`<B*P`(T(%@!B`'D*L`"$S?"(!.=4CG`Q`F;P`0+B\`K
  1551. M%"PO`!@(*P`!`!MG#B\+2'C__TZZ[Q103V`:<`&\@&84""L`!P`:9P@@*P`(D
  1552. MWH!@!)ZK``@G:P`0``1P`"=```PG0``(""L`!P`;9P9P_,&K`!@O!B\'+RL`"
  1553. M'$ZZ_8Q/[P`,4H!F!'#_8`APS\&K`!AP`$S?",!.=2\+)F\`""`+9Q!"ITZZ=
  1554. M_1)83R!+68@I2!3`<``F7TYU````````<&%(YP$P)F\`$"1O`!1^`!X;2H=GK
  1555. M$B\*+P=.N@`64$]2@&;J</]@`G``3-\,@$YU``!(YP$0+B\`#"9O`!`(*P`&B
  1556. M`!MG$G`*OH!F#"\++P=.NNXX4$]@,%.K``QM%B!K``1#Z``!)TD`!"`'$(!RP
  1557. M`!(`8!(@!W(`$@`O"R\!3KKN"E!/(@`@`4S?"(!.=4CG`2`N+P`,4JP4S"!L4
  1558. M%,A3J``,;18B:``$1>D``2%*``0@!Q*`<@`2`&`2(`=R`!(`+P@O`4ZZ[<10<
  1559. M3R(`3-\$@$YU3E4``$CG`#`F;P`0)&\`%$*L%,PI2Q3(2&T`$"\*2'K_G$ZZR
  1560. MZE0NBTAX__].NNV*("P4S$SM#`#_^$Y=3G4``$Y5__A(YP`P1^P#$"`+9PQ*Q
  1561. MJP`89P8D2R938/`@"V8B2'@`(DZZ_8Y83R9`2H!F!'``8!PDBW`A<@`@2Q#!K
  1562. M4<C__"\++RT`#"\M``A.N@`.3.T,`/_P3EU.=0``3E7_\$CG#S`F;P`T)&\`N
  1563. M.$JJ`!AG""\*3KH!LEA/*BP#>'X!<``0,W@`#$``8F<*#$``868,>@!@!BH\-
  1564. M``"``%*'<BNR,W@`5\!$`$B`2,`H`'``$!,,0`!W9P``B`Q``')G0@Q``&%FE
  1565. M``"^2'@`#"\\``"!`B\M``A.NOE83^\`#"P`</^\@&8&<`!@``#02H1G!G!`-
  1566. MT(!@`G`"+@``1T``8```B$J$9P1P`F`"<```0(``2'@`#"\`+RT`"$ZZ^11/!
  1567. M[P`,+`!P_[R`9@9P`&```(Q*A&<&<$#0@&`"<`$N`&!(2H1G!'`"8`)P`0!`\
  1568. M@```0`$``$`"`$AX``PO`"\M``A.NOC.3^\`#"P`</^\@&8$<`!@1DJ$9P9P\
  1569. M0-"`8`)P`BX`8`1P`&`RD<@E2``0<``E0``4)48`'"5J`!``!"5```PE0``(_
  1570. M2H5F!B`\``"``"('@H`E00`8(`I,WPSP3EU.=0``2.</,"9O`!PN+P`@)&\`N
  1571. M)"@+4X<L!TJ&:S13J@`(;1(@:@`$0^@``25)``1P`!`08`@O"DZZ[AI83RH`5
  1572. M</^Z@&<,4X8@!1;`<@JZ@6;(0A.\AV8$<`!@!"!$(`A,WPSP3G4``$CG`S`FI
  1573. M;P`4""L``0`;9Q`O"TAX__].NNLX4$\N`&`"?@`@*P`80H!G%$JK`!1G#B\K1
  1574. M`!0O*P`03KKVZE!/+RL`'$ZZ!7A83RP`</^^@&<&2H9F`G``3-\,P$YU2.<#!
  1575. M$"XO`!!'[`,0(`MG-`@K``(`&V8H""L``0`;9R`@*P`$D*L`$"P`2H9G$B\&!
  1576. M+RL`$"\K`!Q.NN*F3^\`#"938,@O!TZZ[M!83TS?",!.=0``2.<W$"XO`!PF)
  1577. M;P`@+"\`)$JL!=1G!$ZZ!7Q"K`6\(@<D"R8&+&P4U$ZN_]`J`'#_NH!F#DZN2
  1578. M_WPI0`6\<`4I0!30(`5,WPCL3G4``$CG/P`N+P`<+"\`("HO`"1*K`749P1.5
  1579. MN@4P0JP%O"`%4X`B!R0&)@`L;!343J[_OB@`</^X@&8.3J[_?"E`!;QP%BE`;
  1580. M%-`@!0R``````F<6#(`````!9PA*@&88(`9@%"`$T(9@#B('=`!V`"QL%-1.[
  1581. MKO^^3-\`_$YU``!(YS<0+B\`'"9O`"`L+P`D2JP%U&<$3KH$M$*L!;PB!R0+Y
  1582. M)@8L;!343J[_UBH`</^Z@&8.3J[_?"E`!;QP!2E`%-`@!4S?".Q.=0``2.<C`
  1583. M$"9O`!0N+P`82JP%U&<$3KH$;$*L!;PB"R0'+&P4U$ZN_^(L`$J&9A).KO]\O
  1584. M*4`%O'`"*4`4T'#_8`(@!DS?",1.=0``3E7__$CG(1`F;P`82JP%U&<$3KH$+
  1585. M)$*L!;PB"W3^+&P4U$ZN_ZPN`$J'9PHB!TZN_Z9P_V`F(@LD/````^Y.KO_BC
  1586. M+@!*AV823J[_?"E`!;QP`BE`%-!P_V`"(`=,WPB$3EU.=4Y5__Q(YR$0)F\`'
  1587. M&$JL!=1G!$ZZ`\!"K`6\(@MT_BQL%-1.KO^L+@!*AV<,(@=.KO^F(@M.KO^XN
  1588. M(@LD/````^Y.KO_B+@!*AV823J[_?"E`!;QP`BE`%-!P_V`"(`=,WPB$3EU.:
  1589. M=0``+P<N+P`(2JP%U&<$3KH#7B('+&P4U$ZN_]QP`"X?3G5.5?^P+PY*K!3$0
  1590. M9A)#^@"(<``L>``$3J[]V"E`%,1P`"!L!>P0*/__0^W_L&`"$MA3@&3Z<``@V
  1591. M;`7L$"C__T(U"+!![?^P*4@$'$AX`"A(>`#Z<``O`"\`2&P$.'(`+P%(;`0D.
  1592. M+P%.N@,T2'@`%$ZZ[`PL;?^L3EU.=2HJ(%-T86-K($]V97)F;&]W("HJ``!%,
  1593. M6$E4``!I;G1U:71I;VXN;&EB<F%R>0````````````````!(YS``)``F`4A"O
  1594. M2$/$P<;`P,'40TA"0D+0@DS?``Q.=4J`:@``'D2`2H%J```,1(%A```@1(%.X
  1595. M=6$``!A$@$2!3G5*@6H```Q$@6$```9$@$YU+P)(030!9@``(DA`2$%(0C0`T
  1596. M9P``!H3!,`)(0#0`A,$P`DA",@(D'TYU+P-V$`Q!`(!D```&X9E10PQ!"`!D1
  1597. M```&Z9E90PQ!(`!D```&Y9E50TI!:P``!N.94T,T`.:H2$)"0N:J2$.`P38`!
  1598. M,`(T`TA!Q,&0@F0```A30]"!9/YR`#(#2$/GN$A`P4$F'R0?3G5.5?^>2.<S&
  1599. M,GX`(&P%[!XH__]P3[Z`;P(N`"`'0^W_KV`"$MA3@&3Z0C5XKY/)+'@`!$ZNM
  1600. M_MHF0$JK`*QG3"`K`*SE@"1`+"H`.$J&9@0L*P"@2H9G-"(&0?H`LB0(=@LLJ
  1601. M;!343J[_T"!'4H<@"!N\``H(KR(&0>W_KR0()@<L;!343J[_T'#_8$Y*K!3$R
  1602. M9A)#^@"&<``L>``$3J[]V"E`%,1![?^O*4@$;$AX`#Q(>`#Z<``O`"\`2&P$>
  1603. MB$AL!'1(;`1@0J=.N@$\3^\`(%.`9P1P_V`"<`!,WTS,3EU.=2HJ(%5S97(@[
  1604. M06)O<G0@4F5Q=65S=&5D("HJ``!#3TY424Y510``04)/4E0`*BHJ($)R96%K>
  1605. M.B``:6YT=6ET:6]N+FQI8G)A<GD```!(YP$0+B\`#"\'3KH`/%A/)D`@"V8$E
  1606. M</]@*`@K``(``V<&<``F@&`:+RL`!$ZZ_.Y83W``)H!*K`6\9P1P_V`"<`!,H
  1607. MWPB`3G4O!RXO``AP`"E`!;Q*AVLBOJP"]&P<(`?G@$'L$JA*L`@`9PX@!^>`?
  1608. M0>P2J-'`(`A@"'`)*4`4T'``+A].=0``2.<!`G``(CP``#``+'@`!$ZN_LXN<
  1609. M``*'```P`$J'9@1P`&`@2JP%U&<8(&P%U$Z02H!F!'``8`Q(>``43KKH\EA/B
  1610. M(`=,WT"`3G5AM$YU``!(YS`R+&P4Q"!O`!@B;P`<)&\`("9O`"0@+P`H(B\`V
  1611. M+"0O`#`F+P`T3J[^I$S?3`Q.=0`````#[`````$````!````!@````````/R(
  1612. M```#Z@```79`*",I8W1A9W,N8PDT+C<@*$)E<FME;&5Y*2`X+S$X+S@S````+
  1613. M``````$`````+P!T86=S```````P(`P)"@``````.B`)"B(G(R@I6UU[?3TM2
  1614. M*R4J+R9\7GXA/#X[+"XZ/P``````1$%"0T1%1D=(24I+3$U.3U!14E-45597H
  1615. M6%E:7V%B8V1E9F=H:6IK;&UN;W!Q<G-T=79W>'EZ`````&A!0D-$149'2$E*H
  1616. M2TQ-3D]045)35%565UA96E]A8F-D969G:&EJ:VQM;F]P<7)S='5V=WAY>C`Q'
  1617. M,C,T-38W.#D`````HBP[``````#F57-A9V4Z(&-T86=S(%LM0D9A='5W=GA=X
  1618. M(&9I;&4@+BXN"@``;78@)7,@3U1!1U,[9F=R97`@+78@)PDE<PDG($]404=3U
  1619. M(#XE<SMR;2!/5$%'4P``80!W`'-O<G0@)7,@+6\@)7,`<@`[*%L`>7EL97@`E
  1620. M8W1A9W,Z('1O;R!M86YY(&5N=')I97,@=&\@<V]R=`H``&UA:6X``$TE<P`D0
  1621. M`&1E9FEN90``='EP961E9@!S=')U8W0``'5N:6]N`&5N=6T``'EY<&%R<V4`L
  1622. M1'5P;&EC871E(&5N=')Y(&EN(&9I;&4@)7,L(&QI;F4@)60Z("5S"@``4V5C0
  1623. M;VYD(&5N=')Y(&EG;F]R960*`$1U<&QI8V%T92!E;G1R>2!I;B!F:6QE<R`E!
  1624. M<R!A;F0@)7,Z("5S("A787)N:6YG(&]N;'DI"@``)7,))7,))6->`%Q<``!<?
  1625. M)6,`)6,*`"5S"25S"25D"@`E<R`E<R`E9`H`)2TQ-G,E-&0@)2TQ-G,@)7,*I
  1626. M`````!"2:6YT96=E<@!R96%L``!L;V=I8V%L`&-O;7!L97@`8VAA<F%C=&5RT
  1627. M`&1O=6)L90``<')E8VES:6]N`&9U;F-T:6]N``!S=6)R;W5T:6YE``!P<F]GU
  1628. M<F%M`'!R;V-E9'5R90!M971H;V0``'=R87!P97(`=VAO<'!E<@`E)0``````:
  1629. M```H`````````````````````````````(`````#,@``````````````````=
  1630. M`````````````````````````U0`````````````````````````````````7
  1631. M`````````````````````````````````````````````````````````(```
  1632. M````(@``)GP``":0```FH@``)KP``";,```FY```)NX``"<(```G'@``)S``_
  1633. M`"=````G4@``)VP``">````GC@``)YH``">P```GP@``)]8``"?H```G^```[
  1634. M*`@``"@8```H*@``*$@``"AX```HB```*)H``"BL```HN@``*,X``"CD```HD
  1635. M]```*0```"D>```$`/__````#@`.````````````````__\````$``0`````(
  1636. M```YF@``!!#__P````0`!````````#FP`````/__````#@`.````````.Y@`#
  1637. M````__\````$``0`````````````!$S__P````0`!````````#NT`````/__)
  1638. M````!``$````````.[X``````"`@("`@("`@("@H*"@H("`@("`@("`@("`@I
  1639. M("`@("`@2!`0$!`0$!`0$!`0$!`0$(2$A(2$A(2$A(00$!`0$!`0@8&!@8&!6
  1640. M`0$!`0$!`0$!`0$!`0$!`0$!`0$0$!`0$!""@H*"@H("`@("`@("`@("`@(":
  1641. M`@("`@("`A`0$!`@("`@("`@("`@*"@H*"@@("`@("`@("`@("`@("`@("!(>
  1642. M$!`0$!`0$!`0$!`0$!`0A(2$A(2$A(2$A!`0$!`0$!"!@8&!@8$!`0$!`0$!5
  1643. M`0$!`0$!`0$!`0$!`1`0$!`0$(*"@H*"@@("`@("`@("`@("`@("`@("`@("A
  1644. M$!`0$"````````(`````#````.H```#B````G@```&0```!`````-@```"0`6
  1645. M``)P```#,@```Q````0T```$<````^P````H````````!)0```2````$6```U
  1646. M!$0```0P```$"```!`0```0````#_````_@```/T```#\````^P```/H```#5
  1647. MY````^````/<```#V````]0```/0```#S````\@```/$```#P````[P```.X)
  1648. M```#M````[````.L```#J````Z0```.@```#G````Y@```.4```#D````XP`!
  1649. 3``.(```#A````X`````````#\J0`N
  1650. ``
  1651. end
  1652. size 17344
  1653. SHAR_EOF
  1654. cat << \SHAR_EOF > tags
  1655. C_entries    ctags.c    /^C_entries()$/
  1656. L_funcs    ctags.c    /^L_funcs (fi)$/
  1657. L_getit    ctags.c    /^L_getit(special)$/
  1658. Mctags    ctags.c    /^main(ac,av)$/
  1659. NODE    ctags.c    53
  1660. PF_funcs    ctags.c    /^PF_funcs(fi)$/
  1661. TYST    ctags.c    65
  1662. Y_entries    ctags.c    /^Y_entries()$/
  1663. add_node    ctags.c    /^add_node(node, cur_node)$/
  1664. begtoken    ctags.c    /^#define    begtoken(arg)    (_btk[arg])    \/* T if char can/
  1665. cfree    ctags.c    /^# define cfree(C) free(C)$/
  1666. endtoken    ctags.c    /^#define    endtoken(arg)    (_etk[arg])    \/* T if char end/
  1667. find_entries    ctags.c    /^find_entries(file)$/
  1668. first_char    ctags.c    /^first_char()$/
  1669. free_tree    ctags.c    /^free_tree(node)$/
  1670. getit    ctags.c    /^getit()$/
  1671. getline    ctags.c    /^getline()$/
  1672. index    ctags.c    /^# define index(S, C) strchr(S, C)$/
  1673. init    ctags.c    /^init()$/
  1674. intoken    ctags.c    /^#define    intoken(arg)    (_itk[arg])    \/* T if char can /
  1675. isgood    ctags.c    /^#define    isgood(arg)    (_gd[arg])    \/* T if char can be/
  1676. iswhite    ctags.c    /^#define    iswhite(arg)    (_wht[arg])    \/* T if char is w/
  1677. max    ctags.c    /^# define    max(I1,I2)    (I1 > I2 ? I1 : I2)$/
  1678. pfnote    ctags.c    /^pfnote(name, ln, f)$/
  1679. put_entries    ctags.c    /^put_entries(node)$/
  1680. rindex    ctags.c    /^rindex(sp, c)$/
  1681. savestr    ctags.c    /^savestr(cp)$/
  1682. start_entry    ctags.c    /^start_entry(lp,token,tp,f)$/
  1683. striccmp    ctags.c    /^striccmp(str, pat)$/
  1684. tail    ctags.c    /^tail(cp)$/
  1685. takeprec    ctags.c    /^takeprec()$/
  1686. toss_comment    ctags.c    /^toss_comment(start)$/
  1687. toss_yysec    ctags.c    /^toss_yysec()$/
  1688. SHAR_EOF
  1689. #    End of shell archive
  1690. exit 0
  1691. -- 
  1692. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  1693. Have five nice days.
  1694.